home *** CD-ROM | disk | FTP | other *** search
/ PD Collection CD 1 / PD Collection CD 1.iso / textual / tex / files / !tex / TeXsource / web2ctex / ctex / c / tex5 < prev    next >
Encoding:
Text File  |  1988-05-19  |  64.4 KB  |  2,406 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. zmathkern ( p , m ) 
  5. halfword p ; 
  6. scaled m ; 
  7. {mathkern_regmem 
  8.   integer n  ; 
  9.   scaled f  ; 
  10.   if ( mem [ p ] .hh.b1 == 99 ) 
  11.   {
  12.     n = xovern ( m , 65536L ) ; 
  13.     f = remainder ; 
  14.     mem [ p + 1 ] .cint = nxplusy ( n , mem [ p + 1 ] .cint , xnoverd ( mem [ 
  15.     p + 1 ] .cint , f , 65536L ) ) ; 
  16.     mem [ p ] .hh.b1 = 0 ; 
  17.   } 
  18. } 
  19. flushmath () {
  20.     flushmath_regmem 
  21.   flushnodelist ( mem [ curlist .headfield ] .hh .v.RH ) ; 
  22.   flushnodelist ( curlist .auxfield ) ; 
  23.   mem [ curlist .headfield ] .hh .v.RH = 0 ; 
  24.   curlist .tailfield = curlist .headfield ; 
  25.   curlist .auxfield = 0 ; 
  26. } 
  27. halfword zcleanbox ( p , s ) 
  28. halfword p ; 
  29. smallnumber s ; 
  30. {/* 40 */ register halfword Result; cleanbox_regmem 
  31.   halfword q  ; 
  32.   smallnumber savestyle  ; 
  33.   halfword x  ; 
  34.   halfword r  ; 
  35.   switch ( mem [ p ] .hh .v.RH ) 
  36.   {case 1 : 
  37.     {
  38.       curmlist = newnoad () ; 
  39.       mem [ curmlist + 1 ] = mem [ p ] ; 
  40.     } 
  41.     break ; 
  42.   case 2 : 
  43.     {
  44.       q = mem [ p ] .hh .v.LH ; 
  45.       goto lab40 ; 
  46.     } 
  47.     break ; 
  48.   case 3 : 
  49.     curmlist = mem [ p ] .hh .v.LH ; 
  50.     break ; 
  51.     default: 
  52.     {
  53.       q = newnullbox () ; 
  54.       goto lab40 ; 
  55.     } 
  56.     break ; 
  57.   } 
  58.   savestyle = curstyle ; 
  59.   curstyle = s ; 
  60.   mlistpenalties = false ; 
  61.   mlisttohlist () ; 
  62.   q = mem [ memtop - 3 ] .hh .v.RH ; 
  63.   curstyle = savestyle ; 
  64.   {
  65.     if ( curstyle < 4 ) 
  66.     cursize = 0 ; 
  67.     else cursize = 16 * ( ( curstyle - 2 ) / 2 ) ; 
  68.     curmu = xovern ( fontinfo [ 6 + parambase [ eqtb [ 4581 + cursize ] .hh 
  69.     .v.RH ] ] .cint , 18 ) ; 
  70.   } 
  71.   lab40: if ( ( q >= himemmin ) || ( q == 0 ) ) 
  72.   x = hpack ( q , 0 , 1 ) ; 
  73.   else if ( ( mem [ q ] .hh .v.RH == 0 ) && ( mem [ q ] .hh.b0 <= 1 ) && ( mem 
  74.   [ q + 4 ] .cint == 0 ) ) 
  75.   x = q ; 
  76.   else x = hpack ( q , 0 , 1 ) ; 
  77.   q = mem [ x + 5 ] .hh .v.RH ; 
  78.   if ( ( q >= himemmin ) ) 
  79.   {
  80.     r = mem [ q ] .hh .v.RH ; 
  81.     if ( r != 0 ) 
  82.     if ( mem [ r ] .hh .v.RH == 0 ) 
  83.     if ( ! ( r >= himemmin ) ) 
  84.     if ( mem [ r ] .hh.b0 == 11 ) 
  85.     {
  86.       freenode ( r , 2 ) ; 
  87.       mem [ q ] .hh .v.RH = 0 ; 
  88.     } 
  89.   } 
  90.   Result = x ; 
  91.   return(Result) ; 
  92. } 
  93. zfetch ( a ) 
  94. halfword a ; 
  95. {fetch_regmem 
  96.   curc = mem [ a ] .hh.b1 ; 
  97.   curf = eqtb [ 4579 + mem [ a ] .hh.b0 + cursize ] .hh .v.RH ; 
  98.   if ( curf == 0 ) 
  99.   {
  100.     {
  101.       if ( interaction == 3 ) 
  102.       wakeupterminal () ; 
  103.       printnl ( 133 ) ; 
  104.       print ( 206 ) ; 
  105.     } 
  106.     printsize ( cursize ) ; 
  107.     printchar ( 32 ) ; 
  108.     printint ( mem [ a ] .hh.b0 ) ; 
  109.     print ( 737 ) ; 
  110.     printASCII ( curc ) ; 
  111.     printchar ( 41 ) ; 
  112.     {
  113.       helpptr = 4 ; 
  114.       helpline [ 3 ] = 738 ; 
  115.       helpline [ 2 ] = 739 ; 
  116.       helpline [ 1 ] = 740 ; 
  117.       helpline [ 0 ] = 741 ; 
  118.     } 
  119.     error () ; 
  120.     curi = nullcharacter ; 
  121.     mem [ a ] .hh .v.RH = 0 ; 
  122.   } 
  123.   else {
  124.       
  125.     if ( ( curc >= fontbc [ curf ] ) && ( curc <= fontec [ curf ] ) ) 
  126.     curi = fontinfo [ charbase [ curf ] + curc ] .qqqq ; 
  127.     else curi = nullcharacter ; 
  128.     if ( ! ( ( curi .b0 > 0 ) ) ) 
  129.     {
  130.       charwarning ( curf , curc ) ; 
  131.       mem [ a ] .hh .v.RH = 0 ; 
  132.     } 
  133.   } 
  134. } 
  135. zmakeover ( q ) 
  136. halfword q ; 
  137. {makeover_regmem 
  138.   mem [ q + 1 ] .hh .v.LH = overbar ( cleanbox ( q + 1 , 2 * ( curstyle / 2 ) 
  139.   + 1 ) , 3 * fontinfo [ 8 + parambase [ eqtb [ 4582 + cursize ] .hh .v.RH ] ] 
  140.   .cint , fontinfo [ 8 + parambase [ eqtb [ 4582 + cursize ] .hh .v.RH ] ] 
  141.   .cint ) ; 
  142.   mem [ q + 1 ] .hh .v.RH = 2 ; 
  143. } 
  144. zmakeunder ( q ) 
  145. halfword q ; 
  146. {makeunder_regmem 
  147.   halfword p, x, y  ; 
  148.   scaled delta  ; 
  149.   x = cleanbox ( q + 1 , curstyle ) ; 
  150.   p = newkern ( 3 * fontinfo [ 8 + parambase [ eqtb [ 4582 + cursize ] .hh 
  151.   .v.RH ] ] .cint ) ; 
  152.   mem [ x ] .hh .v.RH = p ; 
  153.   mem [ p ] .hh .v.RH = fractionrule ( fontinfo [ 8 + parambase [ eqtb [ 4582 
  154.   + cursize ] .hh .v.RH ] ] .cint ) ; 
  155.   y = vpackage ( x , 0 , 1 , 1073741823L ) ; 
  156.   delta = mem [ y + 3 ] .cint + mem [ y + 2 ] .cint + fontinfo [ 8 + parambase 
  157.   [ eqtb [ 4582 + cursize ] .hh .v.RH ] ] .cint ; 
  158.   mem [ y + 3 ] .cint = mem [ x + 3 ] .cint ; 
  159.   mem [ y + 2 ] .cint = delta - mem [ y + 3 ] .cint ; 
  160.   mem [ q + 1 ] .hh .v.LH = y ; 
  161.   mem [ q + 1 ] .hh .v.RH = 2 ; 
  162. } 
  163. zmakevcenter ( q ) 
  164. halfword q ; 
  165. {makevcenter_regmem 
  166.   halfword v  ; 
  167.   scaled delta  ; 
  168.   v = mem [ q + 1 ] .hh .v.LH ; 
  169.   if ( mem [ v ] .hh.b0 != 1 ) 
  170.   confusion ( 397 ) ; 
  171.   delta = mem [ v + 3 ] .cint + mem [ v + 2 ] .cint ; 
  172.   mem [ v + 3 ] .cint = fontinfo [ 22 + parambase [ eqtb [ 4581 + cursize ] 
  173.   .hh .v.RH ] ] .cint + half ( delta ) ; 
  174.   mem [ v + 2 ] .cint = delta - mem [ v + 3 ] .cint ; 
  175. } 
  176. zmakeradical ( q ) 
  177. halfword q ; 
  178. {makeradical_regmem 
  179.   halfword x, y  ; 
  180.   scaled delta, clr  ; 
  181.   x = cleanbox ( q + 1 , 2 * ( curstyle / 2 ) + 1 ) ; 
  182.   if ( curstyle < 2 ) 
  183.   clr = fontinfo [ 8 + parambase [ eqtb [ 4582 + cursize ] .hh .v.RH ] ] .cint 
  184.   + ( abs ( fontinfo [ 5 + parambase [ eqtb [ 4581 + cursize ] .hh .v.RH ] ] 
  185.   .cint ) / 4 ) ; 
  186.   else {
  187.       
  188.     clr = fontinfo [ 8 + parambase [ eqtb [ 4582 + cursize ] .hh .v.RH ] ] 
  189.     .cint ; 
  190.     clr = clr + ( abs ( clr ) / 4 ) ; 
  191.   } 
  192.   y = vardelimiter ( q + 4 , cursize , mem [ x + 3 ] .cint + mem [ x + 2 ] 
  193.   .cint + clr + fontinfo [ 8 + parambase [ eqtb [ 4582 + cursize ] .hh .v.RH ] 
  194.   ] .cint ) ; 
  195.   delta = mem [ y + 2 ] .cint - ( mem [ x + 3 ] .cint + mem [ x + 2 ] .cint + 
  196.   clr ) ; 
  197.   if ( delta > 0 ) 
  198.   clr = clr + half ( delta ) ; 
  199.   mem [ y + 4 ] .cint = - (integer) ( mem [ x + 3 ] .cint + clr ) ; 
  200.   mem [ y ] .hh .v.RH = overbar ( x , clr , mem [ y + 3 ] .cint ) ; 
  201.   mem [ q + 1 ] .hh .v.LH = hpack ( y , 0 , 1 ) ; 
  202.   mem [ q + 1 ] .hh .v.RH = 2 ; 
  203. } 
  204. zmakemathaccent ( q ) 
  205. halfword q ; 
  206. {/* 30 31 */ makemathaccent_regmem 
  207.   halfword p, x, y  ; 
  208.   integer a  ; 
  209.   quarterword c  ; 
  210.   internalfontnumber f  ; 
  211.   fourquarters i  ; 
  212.   scaled s  ; 
  213.   scaled h  ; 
  214.   scaled delta  ; 
  215.   scaled w  ; 
  216.   fetch ( q + 4 ) ; 
  217.   if ( ( curi .b0 > 0 ) ) 
  218.   {
  219.     i = curi ; 
  220.     c = curc ; 
  221.     f = curf ; 
  222.     s = 0 ; 
  223.     if ( mem [ q + 1 ] .hh .v.RH == 1 ) 
  224.     {
  225.       fetch ( q + 1 ) ; 
  226.       if ( ( ( curi .b2 ) % 4 ) == 1 ) 
  227.       {
  228.     a = ligkernbase [ curf ] + curi .b3 ; 
  229.     do {
  230.         curi = fontinfo [ a ] .qqqq ; 
  231.       if ( curi .b1 == skewchar [ curf ] ) 
  232.       {
  233.         if ( curi .b2 >= 128 ) 
  234.         s = fontinfo [ kernbase [ curf ] + curi .b3 ] .cint ; 
  235.         goto lab31 ; 
  236.       } 
  237.       incr ( a ) ; 
  238.     } while ( ! ( curi .b0 >= 128 ) ) ; 
  239.       } 
  240.     } 
  241.     lab31: ; 
  242.     x = cleanbox ( q + 1 , 2 * ( curstyle / 2 ) + 1 ) ; 
  243.     w = mem [ x + 1 ] .cint ; 
  244.     h = mem [ x + 3 ] .cint ; 
  245.     while ( true ) {
  246.     
  247.       if ( ( ( i .b2 ) % 4 ) != 2 ) 
  248.       goto lab30 ; 
  249.       y = i .b3 ; 
  250.       i = fontinfo [ charbase [ f ] + y ] .qqqq ; 
  251.       if ( fontinfo [ widthbase [ f ] + i .b0 ] .cint > w ) 
  252.       goto lab30 ; 
  253.       c = y ; 
  254.     } 
  255.     lab30: ; 
  256.     if ( h < fontinfo [ 5 + parambase [ f ] ] .cint ) 
  257.     delta = h ; 
  258.     else delta = fontinfo [ 5 + parambase [ f ] ] .cint ; 
  259.     if ( ( mem [ q + 2 ] .hh .v.RH != 0 ) || ( mem [ q + 3 ] .hh .v.RH != 0 ) 
  260.     ) 
  261.     if ( mem [ q + 1 ] .hh .v.RH == 1 ) 
  262.     {
  263.       flushnodelist ( x ) ; 
  264.       x = newnoad () ; 
  265.       mem [ x + 1 ] = mem [ q + 1 ] ; 
  266.       mem [ x + 2 ] = mem [ q + 2 ] ; 
  267.       mem [ x + 3 ] = mem [ q + 3 ] ; 
  268.       mem [ q + 2 ] .hh = emptyfield ; 
  269.       mem [ q + 3 ] .hh = emptyfield ; 
  270.       mem [ q + 1 ] .hh .v.RH = 3 ; 
  271.       mem [ q + 1 ] .hh .v.LH = x ; 
  272.       x = cleanbox ( q + 1 , curstyle ) ; 
  273.       delta = delta + mem [ x + 3 ] .cint - h ; 
  274.       h = mem [ x + 3 ] .cint ; 
  275.     } 
  276.     y = charbox ( f , c ) ; 
  277.     mem [ y + 4 ] .cint = s + half ( w - mem [ y + 1 ] .cint ) ; 
  278.     mem [ y + 1 ] .cint = 0 ; 
  279.     p = newkern ( - (integer) delta ) ; 
  280.     mem [ p ] .hh .v.RH = x ; 
  281.     mem [ y ] .hh .v.RH = p ; 
  282.     y = vpackage ( y , 0 , 1 , 1073741823L ) ; 
  283.     mem [ y + 1 ] .cint = mem [ x + 1 ] .cint ; 
  284.     if ( mem [ y + 3 ] .cint < h ) 
  285.     {
  286.       p = newkern ( h - mem [ y + 3 ] .cint ) ; 
  287.       mem [ p ] .hh .v.RH = mem [ y + 5 ] .hh .v.RH ; 
  288.       mem [ y + 5 ] .hh .v.RH = p ; 
  289.       mem [ y + 3 ] .cint = h ; 
  290.     } 
  291.     mem [ q + 1 ] .hh .v.LH = y ; 
  292.     mem [ q + 1 ] .hh .v.RH = 2 ; 
  293.   } 
  294. } 
  295. zmakefraction ( q ) 
  296. halfword q ; 
  297. {makefraction_regmem 
  298.   halfword p, v, x, y, z  ; 
  299.   scaled delta, delta1, delta2, shiftup, shiftdown, clr  ; 
  300.   if ( mem [ q + 1 ] .cint == 1073741824L ) 
  301.   mem [ q + 1 ] .cint = fontinfo [ 8 + parambase [ eqtb [ 4582 + cursize ] .hh 
  302.   .v.RH ] ] .cint ; 
  303.   x = cleanbox ( q + 2 , curstyle + 2 - 2 * ( curstyle / 6 ) ) ; 
  304.   z = cleanbox ( q + 3 , 2 * ( curstyle / 2 ) + 3 - 2 * ( curstyle / 6 ) ) ; 
  305.   if ( mem [ x + 1 ] .cint < mem [ z + 1 ] .cint ) 
  306.   x = rebox ( x , mem [ z + 1 ] .cint ) ; 
  307.   else z = rebox ( z , mem [ x + 1 ] .cint ) ; 
  308.   if ( curstyle < 2 ) 
  309.   {
  310.     shiftup = fontinfo [ 8 + parambase [ eqtb [ 4581 + cursize ] .hh .v.RH ] ] 
  311.     .cint ; 
  312.     shiftdown = fontinfo [ 11 + parambase [ eqtb [ 4581 + cursize ] .hh .v.RH 
  313.     ] ] .cint ; 
  314.   } 
  315.   else {
  316.       
  317.     shiftdown = fontinfo [ 12 + parambase [ eqtb [ 4581 + cursize ] .hh .v.RH 
  318.     ] ] .cint ; 
  319.     if ( mem [ q + 1 ] .cint != 0 ) 
  320.     shiftup = fontinfo [ 9 + parambase [ eqtb [ 4581 + cursize ] .hh .v.RH ] ] 
  321.     .cint ; 
  322.     else shiftup = fontinfo [ 10 + parambase [ eqtb [ 4581 + cursize ] .hh 
  323.     .v.RH ] ] .cint ; 
  324.   } 
  325.   if ( mem [ q + 1 ] .cint == 0 ) 
  326.   {
  327.     if ( curstyle < 2 ) 
  328.     clr = 7 * fontinfo [ 8 + parambase [ eqtb [ 4582 + cursize ] .hh .v.RH ] ] 
  329.     .cint ; 
  330.     else clr = 3 * fontinfo [ 8 + parambase [ eqtb [ 4582 + cursize ] .hh 
  331.     .v.RH ] ] .cint ; 
  332.     delta = half ( clr - ( ( shiftup - mem [ x + 2 ] .cint ) - ( mem [ z + 3 ] 
  333.     .cint - shiftdown ) ) ) ; 
  334.     if ( delta > 0 ) 
  335.     {
  336.       shiftup = shiftup + delta ; 
  337.       shiftdown = shiftdown + delta ; 
  338.     } 
  339.   } 
  340.   else {
  341.       
  342.     if ( curstyle < 2 ) 
  343.     clr = 3 * mem [ q + 1 ] .cint ; 
  344.     else clr = mem [ q + 1 ] .cint ; 
  345.     delta = half ( mem [ q + 1 ] .cint ) ; 
  346.     delta1 = clr - ( ( shiftup - mem [ x + 2 ] .cint ) - ( fontinfo [ 22 + 
  347.     parambase [ eqtb [ 4581 + cursize ] .hh .v.RH ] ] .cint + delta ) ) ; 
  348.     delta2 = clr - ( ( fontinfo [ 22 + parambase [ eqtb [ 4581 + cursize ] .hh 
  349.     .v.RH ] ] .cint - delta ) - ( mem [ z + 3 ] .cint - shiftdown ) ) ; 
  350.     if ( delta1 > 0 ) 
  351.     shiftup = shiftup + delta1 ; 
  352.     if ( delta2 > 0 ) 
  353.     shiftdown = shiftdown + delta2 ; 
  354.   } 
  355.   v = newnullbox () ; 
  356.   mem [ v ] .hh.b0 = 1 ; 
  357.   mem [ v + 3 ] .cint = shiftup + mem [ x + 3 ] .cint ; 
  358.   mem [ v + 2 ] .cint = mem [ z + 2 ] .cint + shiftdown ; 
  359.   mem [ v + 1 ] .cint = mem [ x + 1 ] .cint ; 
  360.   if ( mem [ q + 1 ] .cint == 0 ) 
  361.   {
  362.     p = newkern ( ( shiftup - mem [ x + 2 ] .cint ) - ( mem [ z + 3 ] .cint - 
  363.     shiftdown ) ) ; 
  364.     mem [ p ] .hh .v.RH = z ; 
  365.   } 
  366.   else {
  367.       
  368.     y = fractionrule ( mem [ q + 1 ] .cint ) ; 
  369.     p = newkern ( ( fontinfo [ 22 + parambase [ eqtb [ 4581 + cursize ] .hh 
  370.     .v.RH ] ] .cint - delta ) - ( mem [ z + 3 ] .cint - shiftdown ) ) ; 
  371.     mem [ y ] .hh .v.RH = p ; 
  372.     mem [ p ] .hh .v.RH = z ; 
  373.     p = newkern ( ( shiftup - mem [ x + 2 ] .cint ) - ( fontinfo [ 22 + 
  374.     parambase [ eqtb [ 4581 + cursize ] .hh .v.RH ] ] .cint + delta ) ) ; 
  375.     mem [ p ] .hh .v.RH = y ; 
  376.   } 
  377.   mem [ x ] .hh .v.RH = p ; 
  378.   mem [ v + 5 ] .hh .v.RH = x ; 
  379.   if ( curstyle < 2 ) 
  380.   delta = fontinfo [ 20 + parambase [ eqtb [ 4581 + cursize ] .hh .v.RH ] ] 
  381.   .cint ; 
  382.   else delta = fontinfo [ 21 + parambase [ eqtb [ 4581 + cursize ] .hh .v.RH ] 
  383.   ] .cint ; 
  384.   x = vardelimiter ( q + 4 , cursize , delta ) ; 
  385.   mem [ x ] .hh .v.RH = v ; 
  386.   z = vardelimiter ( q + 5 , cursize , delta ) ; 
  387.   mem [ v ] .hh .v.RH = z ; 
  388.   mem [ q + 1 ] .cint = hpack ( x , 0 , 1 ) ; 
  389. } 
  390. scaled zmakeop ( q ) 
  391. halfword q ; 
  392. {register scaled Result; makeop_regmem 
  393.   scaled delta  ; 
  394.   halfword p, v, x, y, z  ; 
  395.   scaled shiftup, shiftdown  ; 
  396.   if ( ( mem [ q ] .hh.b1 == 0 ) && ( curstyle < 2 ) ) 
  397.   mem [ q ] .hh.b1 = 1 ; 
  398.   if ( mem [ q + 1 ] .hh .v.RH == 1 ) 
  399.   {
  400.     fetch ( q + 1 ) ; 
  401.     if ( ( curstyle < 2 ) && ( ( ( curi .b2 ) % 4 ) == 2 ) ) 
  402.     {
  403.       curc = curi .b3 ; 
  404.       mem [ q + 1 ] .hh.b1 = curc ; 
  405.       curi = fontinfo [ charbase [ curf ] + curc ] .qqqq ; 
  406.     } 
  407.     delta = fontinfo [ italicbase [ curf ] + ( curi .b2 ) / 4 ] .cint ; 
  408.     x = cleanbox ( q + 1 , curstyle ) ; 
  409.     if ( ( mem [ q + 3 ] .hh .v.RH != 0 ) && ( mem [ q ] .hh.b1 != 1 ) ) 
  410.     mem [ x + 1 ] .cint = mem [ x + 1 ] .cint - delta ; 
  411.     mem [ x + 4 ] .cint = half ( mem [ x + 3 ] .cint - mem [ x + 2 ] .cint ) - 
  412.     fontinfo [ 22 + parambase [ eqtb [ 4581 + cursize ] .hh .v.RH ] ] .cint ; 
  413.     mem [ q + 1 ] .hh .v.RH = 2 ; 
  414.     mem [ q + 1 ] .hh .v.LH = x ; 
  415.   } 
  416.   else delta = 0 ; 
  417.   if ( mem [ q ] .hh.b1 == 1 ) 
  418.   {
  419.     x = cleanbox ( q + 2 , 2 * ( curstyle / 4 ) + 4 + ( curstyle % 2 ) ) ; 
  420.     y = cleanbox ( q + 1 , curstyle ) ; 
  421.     z = cleanbox ( q + 3 , 2 * ( curstyle / 4 ) + 5 ) ; 
  422.     v = newnullbox () ; 
  423.     mem [ v ] .hh.b0 = 1 ; 
  424.     mem [ v + 1 ] .cint = mem [ y + 1 ] .cint ; 
  425.     if ( mem [ x + 1 ] .cint > mem [ v + 1 ] .cint ) 
  426.     mem [ v + 1 ] .cint = mem [ x + 1 ] .cint ; 
  427.     if ( mem [ z + 1 ] .cint > mem [ v + 1 ] .cint ) 
  428.     mem [ v + 1 ] .cint = mem [ z + 1 ] .cint ; 
  429.     x = rebox ( x , mem [ v + 1 ] .cint ) ; 
  430.     y = rebox ( y , mem [ v + 1 ] .cint ) ; 
  431.     z = rebox ( z , mem [ v + 1 ] .cint ) ; 
  432.     mem [ x + 4 ] .cint = half ( delta ) ; 
  433.     mem [ z + 4 ] .cint = - (integer) mem [ x + 4 ] .cint ; 
  434.     mem [ v + 3 ] .cint = mem [ y + 3 ] .cint ; 
  435.     mem [ v + 2 ] .cint = mem [ y + 2 ] .cint ; 
  436.     if ( mem [ q + 2 ] .hh .v.RH == 0 ) 
  437.     {
  438.       freenode ( x , 7 ) ; 
  439.       mem [ v + 5 ] .hh .v.RH = y ; 
  440.     } 
  441.     else {
  442.     
  443.       shiftup = fontinfo [ 11 + parambase [ eqtb [ 4582 + cursize ] .hh .v.RH 
  444.       ] ] .cint - mem [ x + 2 ] .cint ; 
  445.       if ( shiftup < fontinfo [ 9 + parambase [ eqtb [ 4582 + cursize ] .hh 
  446.       .v.RH ] ] .cint ) 
  447.       shiftup = fontinfo [ 9 + parambase [ eqtb [ 4582 + cursize ] .hh .v.RH ] 
  448.       ] .cint ; 
  449.       p = newkern ( shiftup ) ; 
  450.       mem [ p ] .hh .v.RH = y ; 
  451.       mem [ x ] .hh .v.RH = p ; 
  452.       p = newkern ( fontinfo [ 13 + parambase [ eqtb [ 4582 + cursize ] .hh 
  453.       .v.RH ] ] .cint ) ; 
  454.       mem [ p ] .hh .v.RH = x ; 
  455.       mem [ v + 5 ] .hh .v.RH = p ; 
  456.       mem [ v + 3 ] .cint = mem [ v + 3 ] .cint + fontinfo [ 13 + parambase [ 
  457.       eqtb [ 4582 + cursize ] .hh .v.RH ] ] .cint + mem [ x + 3 ] .cint + mem 
  458.       [ x + 2 ] .cint + shiftup ; 
  459.     } 
  460.     if ( mem [ q + 3 ] .hh .v.RH == 0 ) 
  461.     freenode ( z , 7 ) ; 
  462.     else {
  463.     
  464.       shiftdown = fontinfo [ 12 + parambase [ eqtb [ 4582 + cursize ] .hh 
  465.       .v.RH ] ] .cint - mem [ z + 3 ] .cint ; 
  466.       if ( shiftdown < fontinfo [ 10 + parambase [ eqtb [ 4582 + cursize ] .hh 
  467.       .v.RH ] ] .cint ) 
  468.       shiftdown = fontinfo [ 10 + parambase [ eqtb [ 4582 + cursize ] .hh 
  469.       .v.RH ] ] .cint ; 
  470.       p = newkern ( shiftdown ) ; 
  471.       mem [ y ] .hh .v.RH = p ; 
  472.       mem [ p ] .hh .v.RH = z ; 
  473.       p = newkern ( fontinfo [ 13 + parambase [ eqtb [ 4582 + cursize ] .hh 
  474.       .v.RH ] ] .cint ) ; 
  475.       mem [ z ] .hh .v.RH = p ; 
  476.       mem [ v + 2 ] .cint = mem [ v + 2 ] .cint + fontinfo [ 13 + parambase [ 
  477.       eqtb [ 4582 + cursize ] .hh .v.RH ] ] .cint + mem [ z + 3 ] .cint + mem 
  478.       [ z + 2 ] .cint + shiftdown ; 
  479.     } 
  480.     mem [ q + 1 ] .cint = v ; 
  481.   } 
  482.   Result = delta ; 
  483.   return(Result) ; 
  484. } 
  485. zmakeord ( q ) 
  486. halfword q ; 
  487. {/* 20 10 */ makeord_regmem 
  488.   integer a  ; 
  489.   halfword p  ; 
  490.   lab20: if ( ( mem [ q + 3 ] .hh .v.RH == 0 ) && ( mem [ q + 2 ] .hh .v.RH == 
  491.   0 ) && ( mem [ q + 1 ] .hh .v.RH == 1 ) ) 
  492.   {
  493.     p = mem [ q ] .hh .v.RH ; 
  494.     if ( p != 0 ) 
  495.     if ( ( mem [ p ] .hh.b0 >= 16 ) && ( mem [ p ] .hh.b0 <= 22 ) ) 
  496.     if ( mem [ p + 1 ] .hh .v.RH == 1 ) 
  497.     if ( mem [ p + 1 ] .hh.b0 == mem [ q + 1 ] .hh.b0 ) 
  498.     {
  499.       mem [ q + 1 ] .hh .v.RH = 4 ; 
  500.       fetch ( q + 1 ) ; 
  501.       if ( ( ( curi .b2 ) % 4 ) == 1 ) 
  502.       {
  503.     a = ligkernbase [ curf ] + curi .b3 ; 
  504.     curc = mem [ p + 1 ] .hh.b1 ; 
  505.     do {
  506.         curi = fontinfo [ a ] .qqqq ; 
  507.       if ( curi .b1 == curc ) 
  508.       if ( curi .b2 >= 128 ) 
  509.       {
  510.         p = newkern ( fontinfo [ kernbase [ curf ] + curi .b3 ] .cint ) ; 
  511.         mem [ p ] .hh .v.RH = mem [ q ] .hh .v.RH ; 
  512.         mem [ q ] .hh .v.RH = p ; 
  513.         return ; 
  514.       } 
  515.       else {
  516.           
  517.         mem [ q ] .hh .v.RH = mem [ p ] .hh .v.RH ; 
  518.         mem [ q + 1 ] .hh .v.RH = 1 ; 
  519.         mem [ q + 1 ] .hh.b1 = curi .b3 ; 
  520.         mem [ q + 3 ] = mem [ p + 3 ] ; 
  521.         mem [ q + 2 ] = mem [ p + 2 ] ; 
  522.         freenode ( p , 4 ) ; 
  523.         goto lab20 ; 
  524.       } 
  525.       incr ( a ) ; 
  526.     } while ( ! ( curi .b0 >= 128 ) ) ; 
  527.       } 
  528.     } 
  529.   } 
  530. } 
  531. zmakescripts ( q , delta ) 
  532. halfword q ; 
  533. scaled delta ; 
  534. {makescripts_regmem 
  535.   halfword p, x, y, z  ; 
  536.   scaled shiftup, shiftdown, clr  ; 
  537.   smallnumber t  ; 
  538.   p = mem [ q + 1 ] .cint ; 
  539.   if ( ( p >= himemmin ) ) 
  540.   {
  541.     shiftup = 0 ; 
  542.     shiftdown = 0 ; 
  543.   } 
  544.   else {
  545.       
  546.     z = hpack ( p , 0 , 1 ) ; 
  547.     if ( curstyle < 4 ) 
  548.     t = 16 ; 
  549.     else t = 32 ; 
  550.     shiftup = mem [ z + 3 ] .cint - fontinfo [ 18 + parambase [ eqtb [ 4581 + 
  551.     t ] .hh .v.RH ] ] .cint ; 
  552.     shiftdown = mem [ z + 2 ] .cint + fontinfo [ 19 + parambase [ eqtb [ 4581 
  553.     + t ] .hh .v.RH ] ] .cint ; 
  554.     freenode ( z , 7 ) ; 
  555.   } 
  556.   if ( mem [ q + 2 ] .hh .v.RH == 0 ) 
  557.   {
  558.     x = cleanbox ( q + 3 , 2 * ( curstyle / 4 ) + 5 ) ; 
  559.     mem [ x + 1 ] .cint = mem [ x + 1 ] .cint + eqtb [ 5713 ] .cint ; 
  560.     if ( shiftdown < fontinfo [ 16 + parambase [ eqtb [ 4581 + cursize ] .hh 
  561.     .v.RH ] ] .cint ) 
  562.     shiftdown = fontinfo [ 16 + parambase [ eqtb [ 4581 + cursize ] .hh .v.RH 
  563.     ] ] .cint ; 
  564.     clr = mem [ x + 3 ] .cint - ( abs ( fontinfo [ 5 + parambase [ eqtb [ 4581 
  565.     + cursize ] .hh .v.RH ] ] .cint * 4 ) / 5 ) ; 
  566.     if ( shiftdown < clr ) 
  567.     shiftdown = clr ; 
  568.     mem [ x + 4 ] .cint = shiftdown ; 
  569.   } 
  570.   else {
  571.       
  572.     {
  573.       x = cleanbox ( q + 2 , 2 * ( curstyle / 4 ) + 4 + ( curstyle % 2 ) ) ; 
  574.       mem [ x + 1 ] .cint = mem [ x + 1 ] .cint + eqtb [ 5713 ] .cint ; 
  575.       if ( odd ( curstyle ) ) 
  576.       clr = fontinfo [ 15 + parambase [ eqtb [ 4581 + cursize ] .hh .v.RH ] ] 
  577.       .cint ; 
  578.       else if ( curstyle < 2 ) 
  579.       clr = fontinfo [ 13 + parambase [ eqtb [ 4581 + cursize ] .hh .v.RH ] ] 
  580.       .cint ; 
  581.       else clr = fontinfo [ 14 + parambase [ eqtb [ 4581 + cursize ] .hh .v.RH 
  582.       ] ] .cint ; 
  583.       if ( shiftup < clr ) 
  584.       shiftup = clr ; 
  585.       clr = mem [ x + 2 ] .cint + ( abs ( fontinfo [ 5 + parambase [ eqtb [ 
  586.       4581 + cursize ] .hh .v.RH ] ] .cint ) / 4 ) ; 
  587.       if ( shiftup < clr ) 
  588.       shiftup = clr ; 
  589.     } 
  590.     if ( mem [ q + 3 ] .hh .v.RH == 0 ) 
  591.     mem [ x + 4 ] .cint = - (integer) shiftup ; 
  592.     else {
  593.     
  594.       y = cleanbox ( q + 3 , 2 * ( curstyle / 4 ) + 5 ) ; 
  595.       mem [ y + 1 ] .cint = mem [ y + 1 ] .cint + eqtb [ 5713 ] .cint ; 
  596.       if ( shiftdown < fontinfo [ 17 + parambase [ eqtb [ 4581 + cursize ] .hh 
  597.       .v.RH ] ] .cint ) 
  598.       shiftdown = fontinfo [ 17 + parambase [ eqtb [ 4581 + cursize ] .hh 
  599.       .v.RH ] ] .cint ; 
  600.       clr = 4 * fontinfo [ 8 + parambase [ eqtb [ 4582 + cursize ] .hh .v.RH ] 
  601.       ] .cint - ( ( shiftup - mem [ x + 2 ] .cint ) - ( mem [ y + 3 ] .cint - 
  602.       shiftdown ) ) ; 
  603.       if ( clr > 0 ) 
  604.       {
  605.     shiftdown = shiftdown + clr ; 
  606.     clr = ( abs ( fontinfo [ 5 + parambase [ eqtb [ 4581 + cursize ] .hh 
  607.     .v.RH ] ] .cint * 4 ) / 5 ) - ( shiftup - mem [ x + 2 ] .cint ) ; 
  608.     if ( clr > 0 ) 
  609.     {
  610.       shiftup = shiftup + clr ; 
  611.       shiftdown = shiftdown - clr ; 
  612.     } 
  613.       } 
  614.       mem [ x + 4 ] .cint = delta ; 
  615.       p = newkern ( ( shiftup - mem [ x + 2 ] .cint ) - ( mem [ y + 3 ] .cint 
  616.       - shiftdown ) ) ; 
  617.       mem [ x ] .hh .v.RH = p ; 
  618.       mem [ p ] .hh .v.RH = y ; 
  619.       x = vpackage ( x , 0 , 1 , 1073741823L ) ; 
  620.       mem [ x + 4 ] .cint = shiftdown ; 
  621.     } 
  622.   } 
  623.   if ( mem [ q + 1 ] .cint == 0 ) 
  624.   mem [ q + 1 ] .cint = x ; 
  625.   else {
  626.       
  627.     p = mem [ q + 1 ] .cint ; 
  628.     while ( mem [ p ] .hh .v.RH != 0 ) p = mem [ p ] .hh .v.RH ; 
  629.     mem [ p ] .hh .v.RH = x ; 
  630.   } 
  631. } 
  632. smallnumber zmakeleftright ( q , style , maxd , maxh ) 
  633. halfword q ; 
  634. smallnumber style ; 
  635. scaled maxd , maxh ; 
  636. {register smallnumber Result; makeleftright_regmem 
  637.   scaled delta, delta1, delta2  ; 
  638.   if ( style < 4 ) 
  639.   cursize = 0 ; 
  640.   else cursize = 16 * ( ( style - 2 ) / 2 ) ; 
  641.   delta2 = maxd + fontinfo [ 22 + parambase [ eqtb [ 4581 + cursize ] .hh 
  642.   .v.RH ] ] .cint ; 
  643.   delta1 = maxh + maxd - delta2 ; 
  644.   if ( delta2 > delta1 ) 
  645.   delta1 = delta2 ; 
  646.   delta = ( delta1 / 500 ) * eqtb [ 5285 ] .cint ; 
  647.   delta2 = delta1 + delta1 - eqtb [ 5711 ] .cint ; 
  648.   if ( delta < delta2 ) 
  649.   delta = delta2 ; 
  650.   mem [ q + 1 ] .cint = vardelimiter ( q + 1 , cursize , delta ) ; 
  651.   Result = mem [ q ] .hh.b0 - ( 10 ) ; 
  652.   return(Result) ; 
  653. } 
  654. mlisttohlist () {
  655.     /* 21 82 80 81 83 30 */ mlisttohlist_regmem 
  656.   halfword mlist  ; 
  657.   boolean penalties  ; 
  658.   smallnumber style  ; 
  659.   smallnumber savestyle  ; 
  660.   halfword q  ; 
  661.   halfword r  ; 
  662.   smallnumber rtype  ; 
  663.   smallnumber t  ; 
  664.   halfword p, x, y, z  ; 
  665.   integer pen  ; 
  666.   smallnumber s  ; 
  667.   scaled maxh, maxd  ; 
  668.   scaled delta  ; 
  669.   mlist = curmlist ; 
  670.   penalties = mlistpenalties ; 
  671.   style = curstyle ; 
  672.   q = mlist ; 
  673.   r = 0 ; 
  674.   rtype = 17 ; 
  675.   maxh = 0 ; 
  676.   maxd = 0 ; 
  677.   {
  678.     if ( curstyle < 4 ) 
  679.     cursize = 0 ; 
  680.     else cursize = 16 * ( ( curstyle - 2 ) / 2 ) ; 
  681.     curmu = xovern ( fontinfo [ 6 + parambase [ eqtb [ 4581 + cursize ] .hh 
  682.     .v.RH ] ] .cint , 18 ) ; 
  683.   } 
  684.   while ( q != 0 ) {
  685.       
  686.     lab21: delta = 0 ; 
  687.     switch ( mem [ q ] .hh.b0 ) 
  688.     {case 18 : 
  689.       switch ( rtype ) 
  690.       {case 18 : 
  691.       case 17 : 
  692.       case 19 : 
  693.       case 20 : 
  694.       case 22 : 
  695.       case 30 : 
  696.     {
  697.       mem [ q ] .hh.b0 = 16 ; 
  698.       goto lab21 ; 
  699.     } 
  700.     break ; 
  701.     default: 
  702.     ; 
  703.     break ; 
  704.       } 
  705.       break ; 
  706.     case 19 : 
  707.     case 21 : 
  708.     case 22 : 
  709.     case 31 : 
  710.       {
  711.     if ( rtype == 18 ) 
  712.     mem [ r ] .hh.b0 = 16 ; 
  713.     if ( mem [ q ] .hh.b0 == 31 ) 
  714.     goto lab80 ; 
  715.       } 
  716.       break ; 
  717.     case 30 : 
  718.       goto lab80 ; 
  719.       break ; 
  720.     case 25 : 
  721.       {
  722.     makefraction ( q ) ; 
  723.     goto lab82 ; 
  724.       } 
  725.       break ; 
  726.     case 17 : 
  727.       {
  728.     delta = makeop ( q ) ; 
  729.     if ( mem [ q ] .hh.b1 == 1 ) 
  730.     goto lab82 ; 
  731.       } 
  732.       break ; 
  733.     case 16 : 
  734.       makeord ( q ) ; 
  735.       break ; 
  736.     case 20 : 
  737.     case 23 : 
  738.       ; 
  739.       break ; 
  740.     case 24 : 
  741.       makeradical ( q ) ; 
  742.       break ; 
  743.     case 27 : 
  744.       makeover ( q ) ; 
  745.       break ; 
  746.     case 26 : 
  747.       makeunder ( q ) ; 
  748.       break ; 
  749.     case 28 : 
  750.       makemathaccent ( q ) ; 
  751.       break ; 
  752.     case 29 : 
  753.       makevcenter ( q ) ; 
  754.       break ; 
  755.     case 14 : 
  756.       {
  757.     curstyle = mem [ q ] .hh.b1 ; 
  758.     {
  759.       if ( curstyle < 4 ) 
  760.       cursize = 0 ; 
  761.       else cursize = 16 * ( ( curstyle - 2 ) / 2 ) ; 
  762.       curmu = xovern ( fontinfo [ 6 + parambase [ eqtb [ 4581 + cursize ] 
  763.       .hh .v.RH ] ] .cint , 18 ) ; 
  764.     } 
  765.     goto lab81 ; 
  766.       } 
  767.       break ; 
  768.     case 15 : 
  769.       {
  770.     switch ( curstyle / 2 ) 
  771.     {case 0 : 
  772.       {
  773.         p = mem [ q + 1 ] .hh .v.LH ; 
  774.         mem [ q + 1 ] .hh .v.LH = 0 ; 
  775.       } 
  776.       break ; 
  777.     case 1 : 
  778.       {
  779.         p = mem [ q + 1 ] .hh .v.RH ; 
  780.         mem [ q + 1 ] .hh .v.RH = 0 ; 
  781.       } 
  782.       break ; 
  783.     case 2 : 
  784.       {
  785.         p = mem [ q + 2 ] .hh .v.LH ; 
  786.         mem [ q + 2 ] .hh .v.LH = 0 ; 
  787.       } 
  788.       break ; 
  789.     case 3 : 
  790.       {
  791.         p = mem [ q + 2 ] .hh .v.RH ; 
  792.         mem [ q + 2 ] .hh .v.RH = 0 ; 
  793.       } 
  794.       break ; 
  795.     } 
  796.     flushnodelist ( mem [ q + 1 ] .hh .v.LH ) ; 
  797.     flushnodelist ( mem [ q + 1 ] .hh .v.RH ) ; 
  798.     flushnodelist ( mem [ q + 2 ] .hh .v.LH ) ; 
  799.     flushnodelist ( mem [ q + 2 ] .hh .v.RH ) ; 
  800.     mem [ q ] .hh.b0 = 14 ; 
  801.     mem [ q ] .hh.b1 = curstyle ; 
  802.     mem [ q + 1 ] .cint = 0 ; 
  803.     mem [ q + 2 ] .cint = 0 ; 
  804.     if ( p != 0 ) 
  805.     {
  806.       z = mem [ q ] .hh .v.RH ; 
  807.       mem [ q ] .hh .v.RH = p ; 
  808.       while ( mem [ p ] .hh .v.RH != 0 ) p = mem [ p ] .hh .v.RH ; 
  809.       mem [ p ] .hh .v.RH = z ; 
  810.     } 
  811.     goto lab81 ; 
  812.       } 
  813.       break ; 
  814.     case 3 : 
  815.     case 4 : 
  816.     case 5 : 
  817.     case 8 : 
  818.     case 12 : 
  819.     case 7 : 
  820.       goto lab81 ; 
  821.       break ; 
  822.     case 2 : 
  823.       {
  824.     if ( mem [ q + 3 ] .cint > maxh ) 
  825.     maxh = mem [ q + 3 ] .cint ; 
  826.     if ( mem [ q + 2 ] .cint > maxd ) 
  827.     maxd = mem [ q + 2 ] .cint ; 
  828.     goto lab81 ; 
  829.       } 
  830.       break ; 
  831.     case 10 : 
  832.       {
  833.     if ( mem [ q ] .hh.b1 == 99 ) 
  834.     {
  835.       x = mem [ q + 1 ] .hh .v.LH ; 
  836.       y = mathglue ( x , curmu ) ; 
  837.       deleteglueref ( x ) ; 
  838.       mem [ q + 1 ] .hh .v.LH = y ; 
  839.       mem [ q ] .hh.b1 = 0 ; 
  840.     } 
  841.     else if ( ( cursize != 0 ) && ( mem [ q ] .hh.b1 == 98 ) ) 
  842.     {
  843.       p = mem [ q ] .hh .v.RH ; 
  844.       if ( p != 0 ) 
  845.       if ( ( mem [ p ] .hh.b0 == 10 ) || ( mem [ p ] .hh.b0 == 11 ) ) 
  846.       {
  847.         mem [ q ] .hh .v.RH = mem [ p ] .hh .v.RH ; 
  848.         mem [ p ] .hh .v.RH = 0 ; 
  849.         flushnodelist ( p ) ; 
  850.       } 
  851.     } 
  852.     goto lab81 ; 
  853.       } 
  854.       break ; 
  855.     case 11 : 
  856.       {
  857.     mathkern ( q , curmu ) ; 
  858.     goto lab81 ; 
  859.       } 
  860.       break ; 
  861.       default: 
  862.       confusion ( 742 ) ; 
  863.       break ; 
  864.     } 
  865.     switch ( mem [ q + 1 ] .hh .v.RH ) 
  866.     {case 1 : 
  867.     case 4 : 
  868.       {
  869.     fetch ( q + 1 ) ; 
  870.     if ( ( curi .b0 > 0 ) ) 
  871.     {
  872.       delta = fontinfo [ italicbase [ curf ] + ( curi .b2 ) / 4 ] .cint ; 
  873.       p = newcharacter ( curf , curc ) ; 
  874.       if ( ( mem [ q + 1 ] .hh .v.RH == 4 ) && ( fontinfo [ 2 + parambase 
  875.       [ curf ] ] .cint != 0 ) ) 
  876.       delta = 0 ; 
  877.       if ( ( mem [ q + 3 ] .hh .v.RH == 0 ) && ( delta != 0 ) ) 
  878.       {
  879.         mem [ p ] .hh .v.RH = newkern ( delta ) ; 
  880.         delta = 0 ; 
  881.       } 
  882.     } 
  883.     else p = 0 ; 
  884.       } 
  885.       break ; 
  886.     case 0 : 
  887.       p = 0 ; 
  888.       break ; 
  889.     case 2 : 
  890.       p = mem [ q + 1 ] .hh .v.LH ; 
  891.       break ; 
  892.     case 3 : 
  893.       {
  894.     curmlist = mem [ q + 1 ] .hh .v.LH ; 
  895.     savestyle = curstyle ; 
  896.     mlistpenalties = false ; 
  897.     mlisttohlist () ; 
  898.     curstyle = savestyle ; 
  899.     {
  900.       if ( curstyle < 4 ) 
  901.       cursize = 0 ; 
  902.       else cursize = 16 * ( ( curstyle - 2 ) / 2 ) ; 
  903.       curmu = xovern ( fontinfo [ 6 + parambase [ eqtb [ 4581 + cursize ] 
  904.       .hh .v.RH ] ] .cint , 18 ) ; 
  905.     } 
  906.     p = hpack ( mem [ memtop - 3 ] .hh .v.RH , 0 , 1 ) ; 
  907.       } 
  908.       break ; 
  909.       default: 
  910.       confusion ( 743 ) ; 
  911.       break ; 
  912.     } 
  913.     mem [ q + 1 ] .cint = p ; 
  914.     if ( ( mem [ q + 3 ] .hh .v.RH == 0 ) && ( mem [ q + 2 ] .hh .v.RH == 0 ) 
  915.     ) 
  916.     goto lab82 ; 
  917.     makescripts ( q , delta ) ; 
  918.     lab82: z = hpack ( mem [ q + 1 ] .cint , 0 , 1 ) ; 
  919.     if ( mem [ z + 3 ] .cint > maxh ) 
  920.     maxh = mem [ z + 3 ] .cint ; 
  921.     if ( mem [ z + 2 ] .cint > maxd ) 
  922.     maxd = mem [ z + 2 ] .cint ; 
  923.     freenode ( z , 7 ) ; 
  924.     lab80: r = q ; 
  925.     rtype = mem [ r ] .hh.b0 ; 
  926.     lab81: q = mem [ q ] .hh .v.RH ; 
  927.   } 
  928.   if ( rtype == 18 ) 
  929.   mem [ r ] .hh.b0 = 16 ; 
  930.   p = memtop - 3 ; 
  931.   mem [ p ] .hh .v.RH = 0 ; 
  932.   q = mlist ; 
  933.   rtype = 0 ; 
  934.   curstyle = style ; 
  935.   {
  936.     if ( curstyle < 4 ) 
  937.     cursize = 0 ; 
  938.     else cursize = 16 * ( ( curstyle - 2 ) / 2 ) ; 
  939.     curmu = xovern ( fontinfo [ 6 + parambase [ eqtb [ 4581 + cursize ] .hh 
  940.     .v.RH ] ] .cint , 18 ) ; 
  941.   } 
  942.   while ( q != 0 ) {
  943.       
  944.     t = 16 ; 
  945.     s = 4 ; 
  946.     pen = 10000 ; 
  947.     switch ( mem [ q ] .hh.b0 ) 
  948.     {case 17 : 
  949.     case 20 : 
  950.     case 21 : 
  951.     case 22 : 
  952.     case 23 : 
  953.       t = mem [ q ] .hh.b0 ; 
  954.       break ; 
  955.     case 18 : 
  956.       {
  957.     t = 18 ; 
  958.     pen = eqtb [ 5276 ] .cint ; 
  959.       } 
  960.       break ; 
  961.     case 19 : 
  962.       {
  963.     t = 19 ; 
  964.     pen = eqtb [ 5277 ] .cint ; 
  965.       } 
  966.       break ; 
  967.     case 16 : 
  968.     case 29 : 
  969.     case 27 : 
  970.     case 26 : 
  971.       ; 
  972.       break ; 
  973.     case 24 : 
  974.       s = 5 ; 
  975.       break ; 
  976.     case 28 : 
  977.       s = 5 ; 
  978.       break ; 
  979.     case 25 : 
  980.       {
  981.     t = 23 ; 
  982.     s = 6 ; 
  983.       } 
  984.       break ; 
  985.     case 30 : 
  986.     case 31 : 
  987.       t = makeleftright ( q , style , maxd , maxh ) ; 
  988.       break ; 
  989.     case 14 : 
  990.       {
  991.     curstyle = mem [ q ] .hh.b1 ; 
  992.     s = 3 ; 
  993.     {
  994.       if ( curstyle < 4 ) 
  995.       cursize = 0 ; 
  996.       else cursize = 16 * ( ( curstyle - 2 ) / 2 ) ; 
  997.       curmu = xovern ( fontinfo [ 6 + parambase [ eqtb [ 4581 + cursize ] 
  998.       .hh .v.RH ] ] .cint , 18 ) ; 
  999.     } 
  1000.     goto lab83 ; 
  1001.       } 
  1002.       break ; 
  1003.     case 8 : 
  1004.     case 12 : 
  1005.     case 2 : 
  1006.     case 7 : 
  1007.     case 5 : 
  1008.     case 3 : 
  1009.     case 4 : 
  1010.     case 10 : 
  1011.     case 11 : 
  1012.       {
  1013.     mem [ p ] .hh .v.RH = q ; 
  1014.     p = q ; 
  1015.     q = mem [ q ] .hh .v.RH ; 
  1016.     mem [ p ] .hh .v.RH = 0 ; 
  1017.     goto lab30 ; 
  1018.       } 
  1019.       break ; 
  1020.       default: 
  1021.       confusion ( 744 ) ; 
  1022.       break ; 
  1023.     } 
  1024.     if ( rtype > 0 ) 
  1025.     {
  1026.       switch ( strpool [ rtype * 8 + t + magicoffset ] ) 
  1027.       {case 48 : 
  1028.     x = 0 ; 
  1029.     break ; 
  1030.       case 49 : 
  1031.     if ( curstyle < 4 ) 
  1032.     x = 15 ; 
  1033.     else x = 0 ; 
  1034.     break ; 
  1035.       case 50 : 
  1036.     x = 15 ; 
  1037.     break ; 
  1038.       case 51 : 
  1039.     if ( curstyle < 4 ) 
  1040.     x = 16 ; 
  1041.     else x = 0 ; 
  1042.     break ; 
  1043.       case 52 : 
  1044.     if ( curstyle < 4 ) 
  1045.     x = 17 ; 
  1046.     else x = 0 ; 
  1047.     break ; 
  1048.     default: 
  1049.     confusion ( 746 ) ; 
  1050.     break ; 
  1051.       } 
  1052.       if ( x != 0 ) 
  1053.       {
  1054.     y = mathglue ( eqtb [ 3526 + x ] .hh .v.RH , curmu ) ; 
  1055.     z = newglue ( y ) ; 
  1056.     mem [ y ] .hh .v.RH = 0 ; 
  1057.     mem [ p ] .hh .v.RH = z ; 
  1058.     p = z ; 
  1059.     mem [ z ] .hh.b1 = x + 1 ; 
  1060.       } 
  1061.     } 
  1062.     if ( mem [ q + 1 ] .cint != 0 ) 
  1063.     {
  1064.       mem [ p ] .hh .v.RH = mem [ q + 1 ] .cint ; 
  1065.       do {
  1066.       p = mem [ p ] .hh .v.RH ; 
  1067.       } while ( ! ( mem [ p ] .hh .v.RH == 0 ) ) ; 
  1068.     } 
  1069.     if ( penalties ) 
  1070.     if ( mem [ q ] .hh .v.RH != 0 ) 
  1071.     if ( pen < 10000 ) 
  1072.     {
  1073.       rtype = mem [ mem [ q ] .hh .v.RH ] .hh.b0 ; 
  1074.       if ( rtype != 12 ) 
  1075.       if ( rtype != 19 ) 
  1076.       {
  1077.     z = newpenalty ( pen ) ; 
  1078.     mem [ p ] .hh .v.RH = z ; 
  1079.     p = z ; 
  1080.       } 
  1081.     } 
  1082.     rtype = t ; 
  1083.     lab83: r = q ; 
  1084.     q = mem [ q ] .hh .v.RH ; 
  1085.     freenode ( r , s ) ; 
  1086.     lab30: ; 
  1087.   } 
  1088. } 
  1089. pushalignment () {
  1090.     pushalignment_regmem 
  1091.   halfword p  ; 
  1092.   p = getnode ( 5 ) ; 
  1093.   mem [ p ] .hh .v.RH = alignptr ; 
  1094.   mem [ p ] .hh .v.LH = curalign ; 
  1095.   mem [ p + 1 ] .hh .v.LH = mem [ memtop - 8 ] .hh .v.RH ; 
  1096.   mem [ p + 1 ] .hh .v.RH = curspan ; 
  1097.   mem [ p + 2 ] .cint = curloop ; 
  1098.   mem [ p + 3 ] .cint = alignstate ; 
  1099.   mem [ p + 4 ] .hh .v.LH = curhead ; 
  1100.   mem [ p + 4 ] .hh .v.RH = curtail ; 
  1101.   alignptr = p ; 
  1102.   curhead = getavail () ; 
  1103. } 
  1104. popalignment () {
  1105.     popalignment_regmem 
  1106.   halfword p  ; 
  1107.   {
  1108.     mem [ curhead ] .hh .v.RH = avail ; 
  1109.     avail = curhead ; 
  1110.     ;
  1111. #ifdef STAT
  1112.     decr ( dynused ) ; 
  1113. #endif /* STAT */
  1114.   } 
  1115.   p = alignptr ; 
  1116.   curtail = mem [ p + 4 ] .hh .v.RH ; 
  1117.   curhead = mem [ p + 4 ] .hh .v.LH ; 
  1118.   alignstate = mem [ p + 3 ] .cint ; 
  1119.   curloop = mem [ p + 2 ] .cint ; 
  1120.   curspan = mem [ p + 1 ] .hh .v.RH ; 
  1121.   mem [ memtop - 8 ] .hh .v.RH = mem [ p + 1 ] .hh .v.LH ; 
  1122.   curalign = mem [ p ] .hh .v.LH ; 
  1123.   alignptr = mem [ p ] .hh .v.RH ; 
  1124.   freenode ( p , 5 ) ; 
  1125. } 
  1126. getpreambletoken () {
  1127.     /* 20 */ getpreambletoken_regmem 
  1128.   lab20: gettoken () ; 
  1129.   while ( ( curchr == 128 ) && ( curcmd == 4 ) ) {
  1130.       
  1131.     gettoken () ; 
  1132.     if ( curcmd > 99 ) 
  1133.     {
  1134.       expand () ; 
  1135.       gettoken () ; 
  1136.     } 
  1137.   } 
  1138.   if ( ( curcmd == 74 ) && ( curchr == 3537 ) ) 
  1139.   {
  1140.     scanoptionalequals () ; 
  1141.     scanglue ( 2 ) ; 
  1142.     if ( eqtb [ 5310 ] .cint > 0 ) 
  1143.     geqdefine ( 3537 , 116 , curval ) ; 
  1144.     else eqdefine ( 3537 , 116 , curval ) ; 
  1145.     goto lab20 ; 
  1146.   } 
  1147. } 
  1148. initalign () {
  1149.     /* 30 31 32 22 */ initalign_regmem 
  1150.   halfword savecsptr  ; 
  1151.   halfword p  ; 
  1152.   savecsptr = curcs ; 
  1153.   pushalignment () ; 
  1154.   alignstate = -1000000L ; 
  1155.   if ( ( curlist .modefield == 201 ) && ( ( curlist .tailfield != curlist 
  1156.   .headfield ) || ( curlist .auxfield != 0 ) ) ) 
  1157.   {
  1158.     {
  1159.       if ( interaction == 3 ) 
  1160.       wakeupterminal () ; 
  1161.       printnl ( 133 ) ; 
  1162.       print ( 536 ) ; 
  1163.     } 
  1164.     printesc ( 379 ) ; 
  1165.     print ( 747 ) ; 
  1166.     {
  1167.       helpptr = 3 ; 
  1168.       helpline [ 2 ] = 748 ; 
  1169.       helpline [ 1 ] = 749 ; 
  1170.       helpline [ 0 ] = 750 ; 
  1171.     } 
  1172.     error () ; 
  1173.     flushmath () ; 
  1174.   } 
  1175.   pushnest () ; 
  1176.   if ( curlist .modefield == 201 ) 
  1177.   {
  1178.     curlist .modefield = -1 ; 
  1179.     curlist .auxfield = nest [ nestptr - 2 ] .auxfield ; 
  1180.   } 
  1181.   else if ( curlist .modefield > 0 ) 
  1182.   curlist .modefield = - (integer) curlist .modefield ; 
  1183.   scanspec () ; 
  1184.   newsavelevel ( 6 ) ; 
  1185.   mem [ memtop - 8 ] .hh .v.RH = 0 ; 
  1186.   curalign = memtop - 8 ; 
  1187.   curloop = 0 ; 
  1188.   scannerstatus = 4 ; 
  1189.   warningindex = savecsptr ; 
  1190.   alignstate = -1000000L ; 
  1191.   while ( true ) {
  1192.       
  1193.     mem [ curalign ] .hh .v.RH = newparamglue ( 11 ) ; 
  1194.     curalign = mem [ curalign ] .hh .v.RH ; 
  1195.     if ( curcmd == 5 ) 
  1196.     goto lab30 ; 
  1197.     p = memtop - 4 ; 
  1198.     mem [ p ] .hh .v.RH = 0 ; 
  1199.     while ( true ) {
  1200.     
  1201.       getpreambletoken () ; 
  1202.       if ( curcmd == 6 ) 
  1203.       goto lab31 ; 
  1204.       if ( ( curcmd <= 5 ) && ( curcmd >= 4 ) && ( alignstate == -1000000L ) ) 
  1205.       if ( ( p == memtop - 4 ) && ( curloop == 0 ) && ( curcmd == 4 ) ) 
  1206.       curloop = curalign ; 
  1207.       else {
  1208.       
  1209.     {
  1210.       if ( interaction == 3 ) 
  1211.       wakeupterminal () ; 
  1212.       printnl ( 133 ) ; 
  1213.       print ( 756 ) ; 
  1214.     } 
  1215.     {
  1216.       helpptr = 3 ; 
  1217.       helpline [ 2 ] = 757 ; 
  1218.       helpline [ 1 ] = 758 ; 
  1219.       helpline [ 0 ] = 759 ; 
  1220.     } 
  1221.     backerror () ; 
  1222.     goto lab31 ; 
  1223.       } 
  1224.       else if ( ( curcmd != 10 ) || ( p != memtop - 4 ) ) 
  1225.       {
  1226.     mem [ p ] .hh .v.RH = getavail () ; 
  1227.     p = mem [ p ] .hh .v.RH ; 
  1228.     mem [ p ] .hh .v.LH = curtok ; 
  1229.       } 
  1230.     } 
  1231.     lab31: ; 
  1232.     mem [ curalign ] .hh .v.RH = newnullbox () ; 
  1233.     curalign = mem [ curalign ] .hh .v.RH ; 
  1234.     mem [ curalign ] .hh .v.LH = memtop - 9 ; 
  1235.     mem [ curalign + 1 ] .cint = -1073741824L ; 
  1236.     mem [ curalign + 3 ] .cint = mem [ memtop - 4 ] .hh .v.RH ; 
  1237.     p = memtop - 4 ; 
  1238.     mem [ p ] .hh .v.RH = 0 ; 
  1239.     while ( true ) {
  1240.     
  1241.       lab22: getpreambletoken () ; 
  1242.       if ( ( curcmd <= 5 ) && ( curcmd >= 4 ) && ( alignstate == -1000000L ) ) 
  1243.       goto lab32 ; 
  1244.       if ( curcmd == 6 ) 
  1245.       {
  1246.     {
  1247.       if ( interaction == 3 ) 
  1248.       wakeupterminal () ; 
  1249.       printnl ( 133 ) ; 
  1250.       print ( 760 ) ; 
  1251.     } 
  1252.     {
  1253.       helpptr = 3 ; 
  1254.       helpline [ 2 ] = 757 ; 
  1255.       helpline [ 1 ] = 758 ; 
  1256.       helpline [ 0 ] = 761 ; 
  1257.     } 
  1258.     error () ; 
  1259.     goto lab22 ; 
  1260.       } 
  1261.       mem [ p ] .hh .v.RH = getavail () ; 
  1262.       p = mem [ p ] .hh .v.RH ; 
  1263.       mem [ p ] .hh .v.LH = curtok ; 
  1264.     } 
  1265.     lab32: mem [ p ] .hh .v.RH = getavail () ; 
  1266.     p = mem [ p ] .hh .v.RH ; 
  1267.     mem [ p ] .hh .v.LH = 7359 ; 
  1268.     mem [ curalign + 2 ] .cint = mem [ memtop - 4 ] .hh .v.RH ; 
  1269.   } 
  1270.   lab30: scannerstatus = 0 ; 
  1271.   newsavelevel ( 6 ) ; 
  1272.   if ( eqtb [ 4064 ] .hh .v.RH != 0 ) 
  1273.   begintokenlist ( eqtb [ 4064 ] .hh .v.RH , 13 ) ; 
  1274.   alignpeek () ; 
  1275. } 
  1276. zinitspan ( p ) 
  1277. halfword p ; 
  1278. {initspan_regmem 
  1279.   pushnest () ; 
  1280.   if ( curlist .modefield == -101 ) 
  1281.   curlist .auxfield = 1000 ; 
  1282.   else {
  1283.       
  1284.     curlist .auxfield = -65536000L ; 
  1285.     normalparagraph () ; 
  1286.   } 
  1287.   curspan = p ; 
  1288. } 
  1289. initrow () {
  1290.     initrow_regmem 
  1291.   pushnest () ; 
  1292.   curlist .modefield = ( -102 ) - curlist .modefield ; 
  1293.   curlist .auxfield = 0 ; 
  1294.   {
  1295.     mem [ curlist .tailfield ] .hh .v.RH = newglue ( mem [ mem [ memtop - 8 ] 
  1296.     .hh .v.RH + 1 ] .hh .v.LH ) ; 
  1297.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1298.   } 
  1299.   mem [ curlist .tailfield ] .hh.b1 = 12 ; 
  1300.   curalign = mem [ mem [ memtop - 8 ] .hh .v.RH ] .hh .v.RH ; 
  1301.   curtail = curhead ; 
  1302.   initspan ( curalign ) ; 
  1303. } 
  1304. initcol () {
  1305.     initcol_regmem 
  1306.   mem [ curalign + 5 ] .hh .v.LH = curcmd ; 
  1307.   if ( curcmd == 63 ) 
  1308.   alignstate = 0 ; 
  1309.   else {
  1310.       
  1311.     backinput () ; 
  1312.     begintokenlist ( mem [ curalign + 3 ] .cint , 1 ) ; 
  1313.   } 
  1314. } 
  1315. boolean fincol () {
  1316.     /* 10 */ register boolean Result; fincol_regmem 
  1317.   halfword p  ; 
  1318.   halfword q, r  ; 
  1319.   halfword s  ; 
  1320.   halfword u  ; 
  1321.   scaled w  ; 
  1322.   glueord o  ; 
  1323.   halfword n  ; 
  1324.   q = mem [ curalign ] .hh .v.RH ; 
  1325.   if ( ( curalign == 0 ) || ( q == 0 ) ) 
  1326.   confusion ( 763 ) ; 
  1327.   p = mem [ q ] .hh .v.RH ; 
  1328.   if ( ( p == 0 ) && ( mem [ curalign + 5 ] .hh .v.LH < 129 ) ) 
  1329.   if ( curloop != 0 ) 
  1330.   {
  1331.     mem [ q ] .hh .v.RH = newnullbox () ; 
  1332.     p = mem [ q ] .hh .v.RH ; 
  1333.     mem [ p ] .hh .v.LH = memtop - 9 ; 
  1334.     mem [ p + 1 ] .cint = -1073741824L ; 
  1335.     curloop = mem [ curloop ] .hh .v.RH ; 
  1336.     q = memtop - 4 ; 
  1337.     r = mem [ curloop + 3 ] .cint ; 
  1338.     while ( r != 0 ) {
  1339.     
  1340.       mem [ q ] .hh .v.RH = getavail () ; 
  1341.       q = mem [ q ] .hh .v.RH ; 
  1342.       mem [ q ] .hh .v.LH = mem [ r ] .hh .v.LH ; 
  1343.       r = mem [ r ] .hh .v.RH ; 
  1344.     } 
  1345.     mem [ q ] .hh .v.RH = 0 ; 
  1346.     mem [ p + 3 ] .cint = mem [ memtop - 4 ] .hh .v.RH ; 
  1347.     q = memtop - 4 ; 
  1348.     r = mem [ curloop + 2 ] .cint ; 
  1349.     while ( r != 0 ) {
  1350.     
  1351.       mem [ q ] .hh .v.RH = getavail () ; 
  1352.       q = mem [ q ] .hh .v.RH ; 
  1353.       mem [ q ] .hh .v.LH = mem [ r ] .hh .v.LH ; 
  1354.       r = mem [ r ] .hh .v.RH ; 
  1355.     } 
  1356.     mem [ q ] .hh .v.RH = 0 ; 
  1357.     mem [ p + 2 ] .cint = mem [ memtop - 4 ] .hh .v.RH ; 
  1358.     curloop = mem [ curloop ] .hh .v.RH ; 
  1359.     mem [ p ] .hh .v.RH = newglue ( mem [ curloop + 1 ] .hh .v.LH ) ; 
  1360.   } 
  1361.   else {
  1362.       
  1363.     {
  1364.       if ( interaction == 3 ) 
  1365.       wakeupterminal () ; 
  1366.       printnl ( 133 ) ; 
  1367.       print ( 764 ) ; 
  1368.     } 
  1369.     printesc ( 752 ) ; 
  1370.     {
  1371.       helpptr = 3 ; 
  1372.       helpline [ 2 ] = 765 ; 
  1373.       helpline [ 1 ] = 766 ; 
  1374.       helpline [ 0 ] = 767 ; 
  1375.     } 
  1376.     mem [ curalign + 5 ] .hh .v.LH = 129 ; 
  1377.     error () ; 
  1378.   } 
  1379.   if ( mem [ curalign + 5 ] .hh .v.LH != 128 ) 
  1380.   {
  1381.     unsave () ; 
  1382.     newsavelevel ( 6 ) ; 
  1383.     {
  1384.       if ( curlist .modefield == -101 ) 
  1385.       {
  1386.     adjusttail = curtail ; 
  1387.     u = hpack ( mem [ curlist .headfield ] .hh .v.RH , 0 , 1 ) ; 
  1388.     w = mem [ u + 1 ] .cint ; 
  1389.     curtail = adjusttail ; 
  1390.     adjusttail = 0 ; 
  1391.       } 
  1392.       else {
  1393.       
  1394.     u = vpackage ( mem [ curlist .headfield ] .hh .v.RH , 0 , 1 , 0 ) ; 
  1395.     w = mem [ u + 3 ] .cint ; 
  1396.       } 
  1397.       n = 0 ; 
  1398.       if ( curspan != curalign ) 
  1399.       {
  1400.     q = curspan ; 
  1401.     do {
  1402.         incr ( n ) ; 
  1403.       q = mem [ mem [ q ] .hh .v.RH ] .hh .v.RH ; 
  1404.     } while ( ! ( q == curalign ) ) ; 
  1405.     if ( n > 255 ) 
  1406.     confusion ( 768 ) ; 
  1407.     q = curspan ; 
  1408.     while ( mem [ mem [ q ] .hh .v.LH ] .hh .v.RH < n ) q = mem [ q ] .hh 
  1409.     .v.LH ; 
  1410.     if ( mem [ mem [ q ] .hh .v.LH ] .hh .v.RH > n ) 
  1411.     {
  1412.       s = getnode ( 2 ) ; 
  1413.       mem [ s ] .hh .v.LH = mem [ q ] .hh .v.LH ; 
  1414.       mem [ s ] .hh .v.RH = n ; 
  1415.       mem [ q ] .hh .v.LH = s ; 
  1416.       mem [ s + 1 ] .cint = w ; 
  1417.     } 
  1418.     else if ( mem [ mem [ q ] .hh .v.LH + 1 ] .cint < w ) 
  1419.     mem [ mem [ q ] .hh .v.LH + 1 ] .cint = w ; 
  1420.       } 
  1421.       else if ( w > mem [ curalign + 1 ] .cint ) 
  1422.       mem [ curalign + 1 ] .cint = w ; 
  1423.       mem [ u ] .hh.b0 = 13 ; 
  1424.       mem [ u ] .hh.b1 = n ; 
  1425.       if ( totalstretch [ 3 ] != 0 ) 
  1426.       o = 3 ; 
  1427.       else if ( totalstretch [ 2 ] != 0 ) 
  1428.       o = 2 ; 
  1429.       else if ( totalstretch [ 1 ] != 0 ) 
  1430.       o = 1 ; 
  1431.       else o = 0 ; 
  1432.       mem [ u + 5 ] .hh.b1 = o ; 
  1433.       mem [ u + 6 ] .cint = totalstretch [ o ] ; 
  1434.       if ( totalshrink [ 3 ] != 0 ) 
  1435.       o = 3 ; 
  1436.       else if ( totalshrink [ 2 ] != 0 ) 
  1437.       o = 2 ; 
  1438.       else if ( totalshrink [ 1 ] != 0 ) 
  1439.       o = 1 ; 
  1440.       else o = 0 ; 
  1441.       mem [ u + 5 ] .hh.b0 = o ; 
  1442.       mem [ u + 4 ] .cint = totalshrink [ o ] ; 
  1443.       popnest () ; 
  1444.       mem [ curlist .tailfield ] .hh .v.RH = u ; 
  1445.       curlist .tailfield = u ; 
  1446.     } 
  1447.     {
  1448.       mem [ curlist .tailfield ] .hh .v.RH = newglue ( mem [ mem [ curalign ] 
  1449.       .hh .v.RH + 1 ] .hh .v.LH ) ; 
  1450.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1451.     } 
  1452.     mem [ curlist .tailfield ] .hh.b1 = 12 ; 
  1453.     if ( mem [ curalign + 5 ] .hh .v.LH >= 129 ) 
  1454.     {
  1455.       Result = true ; 
  1456.       return(Result) ; 
  1457.     } 
  1458.     initspan ( p ) ; 
  1459.   } 
  1460.   alignstate = 1000000L ; 
  1461.   do {
  1462.       getxtoken () ; 
  1463.   } while ( ! ( curcmd != 10 ) ) ; 
  1464.   curalign = p ; 
  1465.   initcol () ; 
  1466.   Result = false ; 
  1467.   return(Result) ; 
  1468. } 
  1469. finrow () {
  1470.     finrow_regmem 
  1471.   halfword p  ; 
  1472.   if ( curlist .modefield == -101 ) 
  1473.   {
  1474.     p = hpack ( mem [ curlist .headfield ] .hh .v.RH , 0 , 1 ) ; 
  1475.     popnest () ; 
  1476.     appendtovlist ( p ) ; 
  1477.     if ( curhead != curtail ) 
  1478.     {
  1479.       mem [ curlist .tailfield ] .hh .v.RH = mem [ curhead ] .hh .v.RH ; 
  1480.       curlist .tailfield = curtail ; 
  1481.     } 
  1482.   } 
  1483.   else {
  1484.       
  1485.     p = vpackage ( mem [ curlist .headfield ] .hh .v.RH , 0 , 1 , 1073741823L 
  1486.     ) ; 
  1487.     popnest () ; 
  1488.     mem [ curlist .tailfield ] .hh .v.RH = p ; 
  1489.     curlist .tailfield = p ; 
  1490.     curlist .auxfield = 1000 ; 
  1491.   } 
  1492.   mem [ p ] .hh.b0 = 13 ; 
  1493.   mem [ p + 6 ] .cint = 0 ; 
  1494.   if ( eqtb [ 4064 ] .hh .v.RH != 0 ) 
  1495.   begintokenlist ( eqtb [ 4064 ] .hh .v.RH , 13 ) ; 
  1496.   alignpeek () ; 
  1497. } 
  1498. finalign () {
  1499.     finalign_regmem 
  1500.   halfword p, q, r, s, u, v  ; 
  1501.   scaled t, w  ; 
  1502.   scaled o  ; 
  1503.   halfword n  ; 
  1504.   scaled rulesave  ; 
  1505.   if ( curgroup != 6 ) 
  1506.   confusion ( 769 ) ; 
  1507.   unsave () ; 
  1508.   if ( curgroup != 6 ) 
  1509.   confusion ( 770 ) ; 
  1510.   unsave () ; 
  1511.   if ( nest [ nestptr - 1 ] .modefield == 201 ) 
  1512.   o = eqtb [ 5716 ] .cint ; 
  1513.   else o = 0 ; 
  1514.   q = mem [ mem [ memtop - 8 ] .hh .v.RH ] .hh .v.RH ; 
  1515.   do {
  1516.       flushlist ( mem [ q + 3 ] .cint ) ; 
  1517.     flushlist ( mem [ q + 2 ] .cint ) ; 
  1518.     p = mem [ mem [ q ] .hh .v.RH ] .hh .v.RH ; 
  1519.     if ( mem [ q + 1 ] .cint == -1073741824L ) 
  1520.     {
  1521.       mem [ q + 1 ] .cint = 0 ; 
  1522.       r = mem [ q ] .hh .v.RH ; 
  1523.       s = mem [ r + 1 ] .hh .v.LH ; 
  1524.       if ( s != 0 ) 
  1525.       {
  1526.     incr ( mem [ 0 ] .hh .v.RH ) ; 
  1527.     deleteglueref ( s ) ; 
  1528.     mem [ r + 1 ] .hh .v.LH = 0 ; 
  1529.       } 
  1530.     } 
  1531.     if ( mem [ q ] .hh .v.LH != memtop - 9 ) 
  1532.     {
  1533.       t = mem [ q + 1 ] .cint + mem [ mem [ mem [ q ] .hh .v.RH + 1 ] .hh 
  1534.       .v.LH + 1 ] .cint ; 
  1535.       r = mem [ q ] .hh .v.LH ; 
  1536.       s = memtop - 9 ; 
  1537.       mem [ s ] .hh .v.LH = p ; 
  1538.       n = 1 ; 
  1539.       do {
  1540.       mem [ r + 1 ] .cint = mem [ r + 1 ] .cint - t ; 
  1541.     u = mem [ r ] .hh .v.LH ; 
  1542.     while ( mem [ r ] .hh .v.RH > n ) {
  1543.         
  1544.       s = mem [ s ] .hh .v.LH ; 
  1545.       n = mem [ mem [ s ] .hh .v.LH ] .hh .v.RH + 1 ; 
  1546.     } 
  1547.     if ( mem [ r ] .hh .v.RH < n ) 
  1548.     {
  1549.       mem [ r ] .hh .v.LH = mem [ s ] .hh .v.LH ; 
  1550.       mem [ s ] .hh .v.LH = r ; 
  1551.       decr ( mem [ r ] .hh .v.RH ) ; 
  1552.       s = r ; 
  1553.     } 
  1554.     else {
  1555.         
  1556.       if ( mem [ r + 1 ] .cint > mem [ mem [ s ] .hh .v.LH + 1 ] .cint ) 
  1557.       mem [ mem [ s ] .hh .v.LH + 1 ] .cint = mem [ r + 1 ] .cint ; 
  1558.       freenode ( r , 2 ) ; 
  1559.     } 
  1560.     r = u ; 
  1561.       } while ( ! ( r == memtop - 9 ) ) ; 
  1562.     } 
  1563.     mem [ q ] .hh.b0 = 13 ; 
  1564.     mem [ q ] .hh.b1 = 0 ; 
  1565.     mem [ q + 3 ] .cint = 0 ; 
  1566.     mem [ q + 2 ] .cint = 0 ; 
  1567.     mem [ q + 5 ] .hh.b1 = 0 ; 
  1568.     mem [ q + 5 ] .hh.b0 = 0 ; 
  1569.     mem [ q + 6 ] .cint = 0 ; 
  1570.     mem [ q + 4 ] .cint = 0 ; 
  1571.     q = p ; 
  1572.   } while ( ! ( q == 0 ) ) ; 
  1573.   saveptr = saveptr - 2 ; 
  1574.   packbeginline = - (integer) curlist .mlfield ; 
  1575.   if ( curlist .modefield == -1 ) 
  1576.   {
  1577.     rulesave = eqtb [ 5717 ] .cint ; 
  1578.     eqtb [ 5717 ] .cint = 0 ; 
  1579.     p = hpack ( mem [ memtop - 8 ] .hh .v.RH , savestack [ saveptr + 1 ] .cint 
  1580.     , savestack [ saveptr + 0 ] .cint ) ; 
  1581.     eqtb [ 5717 ] .cint = rulesave ; 
  1582.   } 
  1583.   else {
  1584.       
  1585.     q = mem [ mem [ memtop - 8 ] .hh .v.RH ] .hh .v.RH ; 
  1586.     do {
  1587.     mem [ q + 3 ] .cint = mem [ q + 1 ] .cint ; 
  1588.       mem [ q + 1 ] .cint = 0 ; 
  1589.       q = mem [ mem [ q ] .hh .v.RH ] .hh .v.RH ; 
  1590.     } while ( ! ( q == 0 ) ) ; 
  1591.     p = vpackage ( mem [ memtop - 8 ] .hh .v.RH , savestack [ saveptr + 1 ] 
  1592.     .cint , savestack [ saveptr + 0 ] .cint , 1073741823L ) ; 
  1593.     q = mem [ mem [ memtop - 8 ] .hh .v.RH ] .hh .v.RH ; 
  1594.     do {
  1595.     mem [ q + 1 ] .cint = mem [ q + 3 ] .cint ; 
  1596.       mem [ q + 3 ] .cint = 0 ; 
  1597.       q = mem [ mem [ q ] .hh .v.RH ] .hh .v.RH ; 
  1598.     } while ( ! ( q == 0 ) ) ; 
  1599.   } 
  1600.   packbeginline = 0 ; 
  1601.   q = mem [ curlist .headfield ] .hh .v.RH ; 
  1602.   s = curlist .headfield ; 
  1603.   while ( q != 0 ) {
  1604.       
  1605.     if ( mem [ q ] .hh.b0 == 13 ) 
  1606.     {
  1607.       if ( curlist .modefield == -1 ) 
  1608.       {
  1609.     mem [ q ] .hh.b0 = 0 ; 
  1610.     mem [ q + 1 ] .cint = mem [ p + 1 ] .cint ; 
  1611.       } 
  1612.       else {
  1613.       
  1614.     mem [ q ] .hh.b0 = 1 ; 
  1615.     mem [ q + 3 ] .cint = mem [ p + 3 ] .cint ; 
  1616.       } 
  1617.       mem [ q + 5 ] .hh.b1 = mem [ p + 5 ] .hh.b1 ; 
  1618.       mem [ q + 5 ] .hh.b0 = mem [ p + 5 ] .hh.b0 ; 
  1619.       mem [ q + 6 ] .gr = mem [ p + 6 ] .gr ; 
  1620.       mem [ q + 4 ] .cint = o ; 
  1621.       r = mem [ mem [ q + 5 ] .hh .v.RH ] .hh .v.RH ; 
  1622.       s = mem [ mem [ p + 5 ] .hh .v.RH ] .hh .v.RH ; 
  1623.       do {
  1624.       n = mem [ r ] .hh.b1 ; 
  1625.     t = mem [ s + 1 ] .cint ; 
  1626.     w = t ; 
  1627.     u = memtop - 4 ; 
  1628.     while ( n > 0 ) {
  1629.         
  1630.       decr ( n ) ; 
  1631.       s = mem [ s ] .hh .v.RH ; 
  1632.       v = mem [ s + 1 ] .hh .v.LH ; 
  1633.       mem [ u ] .hh .v.RH = newglue ( v ) ; 
  1634.       u = mem [ u ] .hh .v.RH ; 
  1635.       mem [ u ] .hh.b1 = 12 ; 
  1636.       t = t + mem [ v + 1 ] .cint ; 
  1637.       if ( mem [ p + 5 ] .hh.b0 == 1 ) 
  1638.       {
  1639.         if ( mem [ v ] .hh.b0 == mem [ p + 5 ] .hh.b1 ) 
  1640.         t = t + round ( mem [ p + 6 ] .gr * mem [ v + 2 ] .cint ) ; 
  1641.       } 
  1642.       else if ( mem [ p + 5 ] .hh.b0 == 2 ) 
  1643.       {
  1644.         if ( mem [ v ] .hh.b1 == mem [ p + 5 ] .hh.b1 ) 
  1645.         t = t - round ( mem [ p + 6 ] .gr * mem [ v + 3 ] .cint ) ; 
  1646.       } 
  1647.       s = mem [ s ] .hh .v.RH ; 
  1648.       mem [ u ] .hh .v.RH = newnullbox () ; 
  1649.       u = mem [ u ] .hh .v.RH ; 
  1650.       t = t + mem [ s + 1 ] .cint ; 
  1651.       if ( curlist .modefield == -1 ) 
  1652.       mem [ u + 1 ] .cint = mem [ s + 1 ] .cint ; 
  1653.       else {
  1654.           
  1655.         mem [ u ] .hh.b0 = 1 ; 
  1656.         mem [ u + 3 ] .cint = mem [ s + 1 ] .cint ; 
  1657.       } 
  1658.     } 
  1659.     if ( curlist .modefield == -1 ) 
  1660.     {
  1661.       mem [ r + 3 ] .cint = mem [ q + 3 ] .cint ; 
  1662.       mem [ r + 2 ] .cint = mem [ q + 2 ] .cint ; 
  1663.       if ( t == mem [ r + 1 ] .cint ) 
  1664.       {
  1665.         mem [ r + 5 ] .hh.b0 = 0 ; 
  1666.         mem [ r + 5 ] .hh.b1 = 0 ; 
  1667.         mem [ r + 6 ] .gr = 0.0 ; 
  1668.       } 
  1669.       else if ( t > mem [ r + 1 ] .cint ) 
  1670.       {
  1671.         mem [ r + 5 ] .hh.b0 = 1 ; 
  1672.         if ( mem [ r + 6 ] .cint == 0 ) 
  1673.         mem [ r + 6 ] .gr = 0.0 ; 
  1674.         else mem [ r + 6 ] .gr = ( t - mem [ r + 1 ] .cint ) / ((double) 
  1675.         mem [ r + 6 ] .cint ) ; 
  1676.       } 
  1677.       else {
  1678.           
  1679.         mem [ r + 5 ] .hh.b1 = mem [ r + 5 ] .hh.b0 ; 
  1680.         mem [ r + 5 ] .hh.b0 = 2 ; 
  1681.         if ( mem [ r + 4 ] .cint == 0 ) 
  1682.         mem [ r + 6 ] .gr = 0.0 ; 
  1683.         else if ( ( mem [ r + 5 ] .hh.b1 == 0 ) && ( mem [ r + 1 ] .cint - 
  1684.         t > mem [ r + 4 ] .cint ) ) 
  1685.         mem [ r + 6 ] .gr = 1.0 ; 
  1686.         else mem [ r + 6 ] .gr = ( mem [ r + 1 ] .cint - t ) / ((double) 
  1687.         mem [ r + 4 ] .cint ) ; 
  1688.       } 
  1689.       mem [ r + 1 ] .cint = w ; 
  1690.       mem [ r ] .hh.b0 = 0 ; 
  1691.     } 
  1692.     else {
  1693.         
  1694.       mem [ r + 1 ] .cint = mem [ q + 1 ] .cint ; 
  1695.       if ( t == mem [ r + 3 ] .cint ) 
  1696.       {
  1697.         mem [ r + 5 ] .hh.b0 = 0 ; 
  1698.         mem [ r + 5 ] .hh.b1 = 0 ; 
  1699.         mem [ r + 6 ] .gr = 0.0 ; 
  1700.       } 
  1701.       else if ( t > mem [ r + 3 ] .cint ) 
  1702.       {
  1703.         mem [ r + 5 ] .hh.b0 = 1 ; 
  1704.         if ( mem [ r + 6 ] .cint == 0 ) 
  1705.         mem [ r + 6 ] .gr = 0.0 ; 
  1706.         else mem [ r + 6 ] .gr = ( t - mem [ r + 3 ] .cint ) / ((double) 
  1707.         mem [ r + 6 ] .cint ) ; 
  1708.       } 
  1709.       else {
  1710.           
  1711.         mem [ r + 5 ] .hh.b1 = mem [ r + 5 ] .hh.b0 ; 
  1712.         mem [ r + 5 ] .hh.b0 = 2 ; 
  1713.         if ( mem [ r + 4 ] .cint == 0 ) 
  1714.         mem [ r + 6 ] .gr = 0.0 ; 
  1715.         else if ( ( mem [ r + 5 ] .hh.b1 == 0 ) && ( mem [ r + 3 ] .cint - 
  1716.         t > mem [ r + 4 ] .cint ) ) 
  1717.         mem [ r + 6 ] .gr = 1.0 ; 
  1718.         else mem [ r + 6 ] .gr = ( mem [ r + 3 ] .cint - t ) / ((double) 
  1719.         mem [ r + 4 ] .cint ) ; 
  1720.       } 
  1721.       mem [ r + 3 ] .cint = w ; 
  1722.       mem [ r ] .hh.b0 = 1 ; 
  1723.     } 
  1724.     mem [ r + 4 ] .cint = 0 ; 
  1725.     if ( u != memtop - 4 ) 
  1726.     {
  1727.       mem [ u ] .hh .v.RH = mem [ r ] .hh .v.RH ; 
  1728.       mem [ r ] .hh .v.RH = mem [ memtop - 4 ] .hh .v.RH ; 
  1729.       r = u ; 
  1730.     } 
  1731.     r = mem [ mem [ r ] .hh .v.RH ] .hh .v.RH ; 
  1732.     s = mem [ mem [ s ] .hh .v.RH ] .hh .v.RH ; 
  1733.       } while ( ! ( r == 0 ) ) ; 
  1734.     } 
  1735.     else if ( mem [ q ] .hh.b0 == 2 ) 
  1736.     {
  1737.       if ( ( mem [ q + 1 ] .cint == -1073741824L ) ) 
  1738.       mem [ q + 1 ] .cint = mem [ p + 1 ] .cint ; 
  1739.       if ( ( mem [ q + 3 ] .cint == -1073741824L ) ) 
  1740.       mem [ q + 3 ] .cint = mem [ p + 3 ] .cint ; 
  1741.       if ( ( mem [ q + 2 ] .cint == -1073741824L ) ) 
  1742.       mem [ q + 2 ] .cint = mem [ p + 2 ] .cint ; 
  1743.       if ( o != 0 ) 
  1744.       {
  1745.     r = mem [ q ] .hh .v.RH ; 
  1746.     mem [ q ] .hh .v.RH = 0 ; 
  1747.     q = hpack ( q , 0 , 1 ) ; 
  1748.     mem [ q + 4 ] .cint = o ; 
  1749.     mem [ q ] .hh .v.RH = r ; 
  1750.     mem [ s ] .hh .v.RH = q ; 
  1751.       } 
  1752.     } 
  1753.     s = q ; 
  1754.     q = mem [ q ] .hh .v.RH ; 
  1755.   } 
  1756.   flushnodelist ( p ) ; 
  1757.   popalignment () ; 
  1758.   t = curlist .auxfield ; 
  1759.   p = mem [ curlist .headfield ] .hh .v.RH ; 
  1760.   q = curlist .tailfield ; 
  1761.   popnest () ; 
  1762.   if ( curlist .modefield == 201 ) 
  1763.   {
  1764.     doassignments () ; 
  1765.     if ( curcmd != 3 ) 
  1766.     {
  1767.       {
  1768.     if ( interaction == 3 ) 
  1769.     wakeupterminal () ; 
  1770.     printnl ( 133 ) ; 
  1771.     print ( 1018 ) ; 
  1772.       } 
  1773.       {
  1774.     helpptr = 2 ; 
  1775.     helpline [ 1 ] = 748 ; 
  1776.     helpline [ 0 ] = 749 ; 
  1777.       } 
  1778.       backerror () ; 
  1779.     } 
  1780.     else {
  1781.     
  1782.       getxtoken () ; 
  1783.       if ( curcmd != 3 ) 
  1784.       {
  1785.     {
  1786.       if ( interaction == 3 ) 
  1787.       wakeupterminal () ; 
  1788.       printnl ( 133 ) ; 
  1789.       print ( 1014 ) ; 
  1790.     } 
  1791.     {
  1792.       helpptr = 2 ; 
  1793.       helpline [ 1 ] = 1015 ; 
  1794.       helpline [ 0 ] = 1016 ; 
  1795.     } 
  1796.     backerror () ; 
  1797.       } 
  1798.     } 
  1799.     popnest () ; 
  1800.     {
  1801.       mem [ curlist .tailfield ] .hh .v.RH = newpenalty ( eqtb [ 5278 ] .cint 
  1802.       ) ; 
  1803.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1804.     } 
  1805.     {
  1806.       mem [ curlist .tailfield ] .hh .v.RH = newparamglue ( 3 ) ; 
  1807.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1808.     } 
  1809.     mem [ curlist .tailfield ] .hh .v.RH = p ; 
  1810.     if ( p != 0 ) 
  1811.     curlist .tailfield = q ; 
  1812.     {
  1813.       mem [ curlist .tailfield ] .hh .v.RH = newpenalty ( eqtb [ 5279 ] .cint 
  1814.       ) ; 
  1815.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1816.     } 
  1817.     {
  1818.       mem [ curlist .tailfield ] .hh .v.RH = newparamglue ( 4 ) ; 
  1819.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1820.     } 
  1821.     curlist .auxfield = t ; 
  1822.     resumeafterdisplay () ; 
  1823.   } 
  1824.   else {
  1825.       
  1826.     curlist .auxfield = t ; 
  1827.     mem [ curlist .tailfield ] .hh .v.RH = p ; 
  1828.     if ( p != 0 ) 
  1829.     curlist .tailfield = q ; 
  1830.     if ( curlist .modefield == 1 ) 
  1831.     buildpage () ; 
  1832.   } 
  1833. } 
  1834. alignpeek () {
  1835.     /* 20 */ alignpeek_regmem 
  1836.   lab20: alignstate = 1000000L ; 
  1837.   do {
  1838.       getxtoken () ; 
  1839.   } while ( ! ( curcmd != 10 ) ) ; 
  1840.   if ( curcmd == 34 ) 
  1841.   {
  1842.     scanleftbrace () ; 
  1843.     newsavelevel ( 7 ) ; 
  1844.     if ( curlist .modefield == -1 ) 
  1845.     normalparagraph () ; 
  1846.   } 
  1847.   else if ( curcmd == 2 ) 
  1848.   finalign () ; 
  1849.   else if ( ( curcmd == 5 ) && ( curchr == 130 ) ) 
  1850.   goto lab20 ; 
  1851.   else {
  1852.       
  1853.     initrow () ; 
  1854.     initcol () ; 
  1855.   } 
  1856. } 
  1857. halfword zfiniteshrink ( p ) 
  1858. halfword p ; 
  1859. {register halfword Result; finiteshrink_regmem 
  1860.   halfword q  ; 
  1861.   if ( noshrinkerroryet ) 
  1862.   {
  1863.     noshrinkerroryet = false ; 
  1864.     {
  1865.       if ( interaction == 3 ) 
  1866.       wakeupterminal () ; 
  1867.       printnl ( 133 ) ; 
  1868.       print ( 771 ) ; 
  1869.     } 
  1870.     {
  1871.       helpptr = 5 ; 
  1872.       helpline [ 4 ] = 772 ; 
  1873.       helpline [ 3 ] = 773 ; 
  1874.       helpline [ 2 ] = 774 ; 
  1875.       helpline [ 1 ] = 775 ; 
  1876.       helpline [ 0 ] = 776 ; 
  1877.     } 
  1878.     error () ; 
  1879.   } 
  1880.   q = newspec ( p ) ; 
  1881.   mem [ q ] .hh.b1 = 0 ; 
  1882.   deleteglueref ( p ) ; 
  1883.   Result = q ; 
  1884.   return(Result) ; 
  1885. } 
  1886. ztrybreak ( pi , breaktype ) 
  1887. integer pi ; 
  1888. smallnumber breaktype ; 
  1889. {/* 10 30 31 22 60 */ trybreak_regmem 
  1890.   halfword r  ; 
  1891.   halfword prevr  ; 
  1892.   halfword oldl  ; 
  1893.   boolean nobreakyet  ; 
  1894.   halfword prevprevr  ; 
  1895.   halfword s  ; 
  1896.   halfword q  ; 
  1897.   halfword v  ; 
  1898.   integer t  ; 
  1899.   internalfontnumber f  ; 
  1900.   halfword l  ; 
  1901.   boolean noderstaysactive  ; 
  1902.   scaled linewidth  ; 
  1903.   schar fitclass  ; 
  1904.   halfword b  ; 
  1905.   integer d  ; 
  1906.   boolean artificialbadness  ; 
  1907.   halfword savelink  ; 
  1908.   scaled shortfall  ; 
  1909.   if ( abs ( pi ) >= 10000 ) 
  1910.   if ( pi > 0 ) 
  1911.   goto lab10 ; 
  1912.   else pi = -10000 ; 
  1913.   nobreakyet = true ; 
  1914.   prevr = memtop - 7 ; 
  1915.   oldl = 0 ; 
  1916.   curactivewidth [ 1 ] = activewidth [ 1 ] ; 
  1917.   curactivewidth [ 2 ] = activewidth [ 2 ] ; 
  1918.   curactivewidth [ 3 ] = activewidth [ 3 ] ; 
  1919.   curactivewidth [ 4 ] = activewidth [ 4 ] ; 
  1920.   curactivewidth [ 5 ] = activewidth [ 5 ] ; 
  1921.   curactivewidth [ 6 ] = activewidth [ 6 ] ; 
  1922.   while ( true ) {
  1923.       
  1924.     lab22: r = mem [ prevr ] .hh .v.RH ; 
  1925.     if ( mem [ r ] .hh.b0 == 2 ) 
  1926.     {
  1927.       curactivewidth [ 1 ] = curactivewidth [ 1 ] + mem [ r + 1 ] .cint ; 
  1928.       curactivewidth [ 2 ] = curactivewidth [ 2 ] + mem [ r + 2 ] .cint ; 
  1929.       curactivewidth [ 3 ] = curactivewidth [ 3 ] + mem [ r + 3 ] .cint ; 
  1930.       curactivewidth [ 4 ] = curactivewidth [ 4 ] + mem [ r + 4 ] .cint ; 
  1931.       curactivewidth [ 5 ] = curactivewidth [ 5 ] + mem [ r + 5 ] .cint ; 
  1932.       curactivewidth [ 6 ] = curactivewidth [ 6 ] + mem [ r + 6 ] .cint ; 
  1933.       prevprevr = prevr ; 
  1934.       prevr = r ; 
  1935.       goto lab22 ; 
  1936.     } 
  1937.     {
  1938.       l = mem [ r + 1 ] .hh .v.LH ; 
  1939.       if ( l > oldl ) 
  1940.       {
  1941.     if ( ( minimumdemerits < 1073741823L ) && ( ( oldl != easyline ) || ( 
  1942.     r == memtop - 7 ) ) ) 
  1943.     {
  1944.       if ( nobreakyet ) 
  1945.       {
  1946.         nobreakyet = false ; 
  1947.         breakwidth [ 1 ] = background [ 1 ] ; 
  1948.         breakwidth [ 2 ] = background [ 2 ] ; 
  1949.         breakwidth [ 3 ] = background [ 3 ] ; 
  1950.         breakwidth [ 4 ] = background [ 4 ] ; 
  1951.         breakwidth [ 5 ] = background [ 5 ] ; 
  1952.         breakwidth [ 6 ] = background [ 6 ] ; 
  1953.         s = curp ; 
  1954.         if ( breaktype > 0 ) 
  1955.         if ( curp != 0 ) 
  1956.         {
  1957.           t = mem [ curp ] .hh.b1 ; 
  1958.           v = curp ; 
  1959.           s = mem [ curp + 1 ] .hh .v.RH ; 
  1960.           while ( t > 0 ) {
  1961.           
  1962.         decr ( t ) ; 
  1963.         v = mem [ v ] .hh .v.RH ; 
  1964.         if ( ( v >= himemmin ) ) 
  1965.         {
  1966.           f = mem [ v ] .hh.b0 ; 
  1967.           breakwidth [ 1 ] = breakwidth [ 1 ] - fontinfo [ widthbase [ 
  1968.           f ] + fontinfo [ charbase [ f ] + mem [ v ] .hh.b1 ] .qqqq 
  1969.           .b0 ] .cint ; 
  1970.         } 
  1971.         else switch ( mem [ v ] .hh.b0 ) 
  1972.         {case 6 : 
  1973.           {
  1974.             f = mem [ v + 1 ] .hh.b0 ; 
  1975.             breakwidth [ 1 ] = breakwidth [ 1 ] - fontinfo [ widthbase 
  1976.             [ f ] + fontinfo [ charbase [ f ] + mem [ v + 1 ] .hh.b1 ] 
  1977.             .qqqq .b0 ] .cint ; 
  1978.           } 
  1979.           break ; 
  1980.         case 0 : 
  1981.         case 1 : 
  1982.         case 2 : 
  1983.         case 11 : 
  1984.           breakwidth [ 1 ] = breakwidth [ 1 ] - mem [ v + 1 ] .cint ; 
  1985.           break ; 
  1986.           default: 
  1987.           confusion ( 777 ) ; 
  1988.           break ; 
  1989.         } 
  1990.           } 
  1991.           while ( s != 0 ) {
  1992.           
  1993.         if ( ( s >= himemmin ) ) 
  1994.         {
  1995.           f = mem [ s ] .hh.b0 ; 
  1996.           breakwidth [ 1 ] = breakwidth [ 1 ] + fontinfo [ widthbase [ 
  1997.           f ] + fontinfo [ charbase [ f ] + mem [ s ] .hh.b1 ] .qqqq 
  1998.           .b0 ] .cint ; 
  1999.         } 
  2000.         else switch ( mem [ s ] .hh.b0 ) 
  2001.         {case 6 : 
  2002.           {
  2003.             f = mem [ s + 1 ] .hh.b0 ; 
  2004.             breakwidth [ 1 ] = breakwidth [ 1 ] + fontinfo [ widthbase 
  2005.             [ f ] + fontinfo [ charbase [ f ] + mem [ s + 1 ] .hh.b1 ] 
  2006.             .qqqq .b0 ] .cint ; 
  2007.           } 
  2008.           break ; 
  2009.         case 0 : 
  2010.         case 1 : 
  2011.         case 2 : 
  2012.           breakwidth [ 1 ] = breakwidth [ 1 ] + mem [ s + 1 ] .cint ; 
  2013.           break ; 
  2014.         case 11 : 
  2015.           if ( ( t == 0 ) && ( mem [ s ] .hh.b1 != 2 ) ) 
  2016.           t = -1 ; 
  2017.           else breakwidth [ 1 ] = breakwidth [ 1 ] + mem [ s + 1 ] 
  2018.           .cint ; 
  2019.           break ; 
  2020.           default: 
  2021.           confusion ( 778 ) ; 
  2022.           break ; 
  2023.         } 
  2024.         incr ( t ) ; 
  2025.         s = mem [ s ] .hh .v.RH ; 
  2026.           } 
  2027.           breakwidth [ 1 ] = breakwidth [ 1 ] + discwidth ; 
  2028.           if ( t == 0 ) 
  2029.           s = mem [ v ] .hh .v.RH ; 
  2030.         } 
  2031.         while ( s != 0 ) {
  2032.         
  2033.           if ( ( s >= himemmin ) ) 
  2034.           goto lab30 ; 
  2035.           switch ( mem [ s ] .hh.b0 ) 
  2036.           {case 10 : 
  2037.         {
  2038.           v = mem [ s + 1 ] .hh .v.LH ; 
  2039.           breakwidth [ 1 ] = breakwidth [ 1 ] - mem [ v + 1 ] .cint ; 
  2040.           breakwidth [ 2 + mem [ v ] .hh.b0 ] = breakwidth [ 2 + mem [ 
  2041.           v ] .hh.b0 ] - mem [ v + 2 ] .cint ; 
  2042.           breakwidth [ 6 ] = breakwidth [ 6 ] - mem [ v + 3 ] .cint ; 
  2043.         } 
  2044.         break ; 
  2045.           case 12 : 
  2046.         ; 
  2047.         break ; 
  2048.           case 9 : 
  2049.           case 11 : 
  2050.         if ( mem [ s ] .hh.b1 == 2 ) 
  2051.         goto lab30 ; 
  2052.         else breakwidth [ 1 ] = breakwidth [ 1 ] - mem [ s + 1 ] .cint 
  2053.         ; 
  2054.         break ; 
  2055.         default: 
  2056.         goto lab30 ; 
  2057.         break ; 
  2058.           } 
  2059.           s = mem [ s ] .hh .v.RH ; 
  2060.         } 
  2061.         lab30: ; 
  2062.       } 
  2063.       if ( mem [ prevr ] .hh.b0 == 2 ) 
  2064.       {
  2065.         mem [ prevr + 1 ] .cint = mem [ prevr + 1 ] .cint - curactivewidth 
  2066.         [ 1 ] + breakwidth [ 1 ] ; 
  2067.         mem [ prevr + 2 ] .cint = mem [ prevr + 2 ] .cint - curactivewidth 
  2068.         [ 2 ] + breakwidth [ 2 ] ; 
  2069.         mem [ prevr + 3 ] .cint = mem [ prevr + 3 ] .cint - curactivewidth 
  2070.         [ 3 ] + breakwidth [ 3 ] ; 
  2071.         mem [ prevr + 4 ] .cint = mem [ prevr + 4 ] .cint - curactivewidth 
  2072.         [ 4 ] + breakwidth [ 4 ] ; 
  2073.         mem [ prevr + 5 ] .cint = mem [ prevr + 5 ] .cint - curactivewidth 
  2074.         [ 5 ] + breakwidth [ 5 ] ; 
  2075.         mem [ prevr + 6 ] .cint = mem [ prevr + 6 ] .cint - curactivewidth 
  2076.         [ 6 ] + breakwidth [ 6 ] ; 
  2077.       } 
  2078.       else if ( prevr == memtop - 7 ) 
  2079.       {
  2080.         activewidth [ 1 ] = breakwidth [ 1 ] ; 
  2081.         activewidth [ 2 ] = breakwidth [ 2 ] ; 
  2082.         activewidth [ 3 ] = breakwidth [ 3 ] ; 
  2083.         activewidth [ 4 ] = breakwidth [ 4 ] ; 
  2084.         activewidth [ 5 ] = breakwidth [ 5 ] ; 
  2085.         activewidth [ 6 ] = breakwidth [ 6 ] ; 
  2086.       } 
  2087.       else {
  2088.           
  2089.         q = getnode ( 7 ) ; 
  2090.         mem [ q ] .hh .v.RH = r ; 
  2091.         mem [ q ] .hh.b0 = 2 ; 
  2092.         mem [ q ] .hh.b1 = 0 ; 
  2093.         mem [ q + 1 ] .cint = breakwidth [ 1 ] - curactivewidth [ 1 ] ; 
  2094.         mem [ q + 2 ] .cint = breakwidth [ 2 ] - curactivewidth [ 2 ] ; 
  2095.         mem [ q + 3 ] .cint = breakwidth [ 3 ] - curactivewidth [ 3 ] ; 
  2096.         mem [ q + 4 ] .cint = breakwidth [ 4 ] - curactivewidth [ 4 ] ; 
  2097.         mem [ q + 5 ] .cint = breakwidth [ 5 ] - curactivewidth [ 5 ] ; 
  2098.         mem [ q + 6 ] .cint = breakwidth [ 6 ] - curactivewidth [ 6 ] ; 
  2099.         mem [ prevr ] .hh .v.RH = q ; 
  2100.         prevprevr = prevr ; 
  2101.         prevr = q ; 
  2102.       } 
  2103.       minimumdemerits = minimumdemerits + abs ( eqtb [ 5283 ] .cint ) ; 
  2104.       {register integer for_end; fitclass = 0 ; for_end = 3 ; if ( 
  2105.       fitclass <= for_end) do 
  2106.         {
  2107.           if ( minimaldemerits [ fitclass ] <= minimumdemerits ) 
  2108.           {
  2109.         q = getnode ( 2 ) ; 
  2110.         mem [ q ] .hh .v.RH = passive ; 
  2111.         passive = q ; 
  2112.         mem [ q + 1 ] .hh .v.RH = curp ; 
  2113.     ;
  2114. #ifdef STAT
  2115.         incr ( passnumber ) ; 
  2116.         mem [ q ] .hh .v.LH = passnumber ; 
  2117. #endif /* STAT */
  2118.         mem [ q + 1 ] .hh .v.LH = bestplace [ fitclass ] ; 
  2119.         q = getnode ( 3 ) ; 
  2120.         mem [ q + 1 ] .hh .v.RH = passive ; 
  2121.         mem [ q + 1 ] .hh .v.LH = bestplline [ fitclass ] + 1 ; 
  2122.         mem [ q ] .hh.b1 = fitclass ; 
  2123.         mem [ q ] .hh.b0 = breaktype ; 
  2124.         mem [ q + 2 ] .cint = minimaldemerits [ fitclass ] ; 
  2125.         mem [ q ] .hh .v.RH = r ; 
  2126.         mem [ prevr ] .hh .v.RH = q ; 
  2127.         prevr = q ; 
  2128.     ;
  2129. #ifdef STAT
  2130.         if ( eqtb [ 5299 ] .cint > 0 ) 
  2131.         {
  2132.           printnl ( 779 ) ; 
  2133.           printint ( mem [ passive ] .hh .v.LH ) ; 
  2134.           print ( 780 ) ; 
  2135.           printint ( mem [ q + 1 ] .hh .v.LH - 1 ) ; 
  2136.           printchar ( 46 ) ; 
  2137.           printint ( fitclass ) ; 
  2138.           if ( breaktype == 1 ) 
  2139.           printchar ( 45 ) ; 
  2140.           print ( 781 ) ; 
  2141.           printint ( mem [ q + 2 ] .cint ) ; 
  2142.           print ( 782 ) ; 
  2143.           if ( mem [ passive + 1 ] .hh .v.LH == 0 ) 
  2144.           printchar ( 48 ) ; 
  2145.           else printint ( mem [ mem [ passive + 1 ] .hh .v.LH ] .hh 
  2146.           .v.LH ) ; 
  2147.         } 
  2148. #endif /* STAT */
  2149.           } 
  2150.           minimaldemerits [ fitclass ] = 1073741823L ; 
  2151.         } 
  2152.       while ( fitclass++ < for_end ) ; } 
  2153.       minimumdemerits = 1073741823L ; 
  2154.       if ( r != memtop - 7 ) 
  2155.       {
  2156.         q = getnode ( 7 ) ; 
  2157.         mem [ q ] .hh .v.RH = r ; 
  2158.         mem [ q ] .hh.b0 = 2 ; 
  2159.         mem [ q ] .hh.b1 = 0 ; 
  2160.         mem [ q + 1 ] .cint = curactivewidth [ 1 ] - breakwidth [ 1 ] ; 
  2161.         mem [ q + 2 ] .cint = curactivewidth [ 2 ] - breakwidth [ 2 ] ; 
  2162.         mem [ q + 3 ] .cint = curactivewidth [ 3 ] - breakwidth [ 3 ] ; 
  2163.         mem [ q + 4 ] .cint = curactivewidth [ 4 ] - breakwidth [ 4 ] ; 
  2164.         mem [ q + 5 ] .cint = curactivewidth [ 5 ] - breakwidth [ 5 ] ; 
  2165.         mem [ q + 6 ] .cint = curactivewidth [ 6 ] - breakwidth [ 6 ] ; 
  2166.         mem [ prevr ] .hh .v.RH = q ; 
  2167.         prevprevr = prevr ; 
  2168.         prevr = q ; 
  2169.       } 
  2170.     } 
  2171.     if ( r == memtop - 7 ) 
  2172.     goto lab10 ; 
  2173.     if ( l > easyline ) 
  2174.     {
  2175.       linewidth = secondwidth ; 
  2176.       oldl = 65534L ; 
  2177.     } 
  2178.     else {
  2179.         
  2180.       oldl = l ; 
  2181.       if ( l > lastspecialline ) 
  2182.       linewidth = secondwidth ; 
  2183.       else if ( eqtb [ 4056 ] .hh .v.RH == 0 ) 
  2184.       linewidth = firstwidth ; 
  2185.       else linewidth = mem [ eqtb [ 4056 ] .hh .v.RH + 2 * l ] .cint ; 
  2186.     } 
  2187.       } 
  2188.     } 
  2189.     {
  2190.     ;
  2191. #ifdef STAT
  2192.       artificialbadness = false ; 
  2193. #endif /* STAT */
  2194.       shortfall = linewidth - curactivewidth [ 1 ] ; 
  2195.       if ( shortfall > 0 ) 
  2196.       if ( ( curactivewidth [ 3 ] != 0 ) || ( curactivewidth [ 4 ] != 0 ) || ( 
  2197.       curactivewidth [ 5 ] != 0 ) ) 
  2198.       {
  2199.     b = 0 ; 
  2200.     fitclass = 2 ; 
  2201.       } 
  2202.       else {
  2203.       
  2204.     if ( shortfall > 7230584L ) 
  2205.     if ( curactivewidth [ 2 ] < 1663497L ) 
  2206.     {
  2207.       b = 10000 ; 
  2208.       fitclass = 0 ; 
  2209.       goto lab31 ; 
  2210.     } 
  2211.     b = badness ( shortfall , curactivewidth [ 2 ] ) ; 
  2212.     if ( b > 12 ) 
  2213.     if ( b > 99 ) 
  2214.     fitclass = 0 ; 
  2215.     else fitclass = 1 ; 
  2216.     else fitclass = 2 ; 
  2217.     lab31: ; 
  2218.       } 
  2219.       else {
  2220.       
  2221.     if ( - (integer) shortfall > curactivewidth [ 6 ] ) 
  2222.     b = 10001 ; 
  2223.     else b = badness ( - (integer) shortfall , curactivewidth [ 6 ] ) ; 
  2224.     if ( b > 12 ) 
  2225.     fitclass = 3 ; 
  2226.     else fitclass = 2 ; 
  2227.       } 
  2228.       if ( ( b > 10000 ) || ( pi == -10000 ) ) 
  2229.       {
  2230.     if ( secondpass && ( minimumdemerits == 1073741823L ) && ( mem [ r ] 
  2231.     .hh .v.RH == memtop - 7 ) && ( prevr == memtop - 7 ) ) 
  2232.     {
  2233.       b = 0 ; 
  2234.     ;
  2235. #ifdef STAT
  2236.       artificialbadness = true ; 
  2237. #endif /* STAT */
  2238.     } 
  2239.     else if ( b > threshold ) 
  2240.     goto lab60 ; 
  2241.     noderstaysactive = false ; 
  2242.       } 
  2243.       else {
  2244.       
  2245.     prevr = r ; 
  2246.     if ( b > threshold ) 
  2247.     goto lab22 ; 
  2248.     noderstaysactive = true ; 
  2249.       } 
  2250.       d = eqtb [ 5269 ] .cint + b ; 
  2251.       d = d * d ; 
  2252.       if ( pi != 0 ) 
  2253.       if ( pi > 0 ) 
  2254.       d = d + pi * pi ; 
  2255.       else if ( pi > -10000 ) 
  2256.       d = d - pi * pi ; 
  2257.       if ( ( breaktype == 1 ) && ( mem [ r ] .hh.b0 == 1 ) ) 
  2258.       if ( curp != 0 ) 
  2259.       d = d + eqtb [ 5281 ] .cint ; 
  2260.       else d = d + eqtb [ 5282 ] .cint ; 
  2261.       if ( abs ( toint ( fitclass ) - toint ( mem [ r ] .hh.b1 ) ) > 1 ) 
  2262.       d = d + eqtb [ 5283 ] .cint ; 
  2263.     ;
  2264. #ifdef STAT
  2265.       if ( eqtb [ 5299 ] .cint > 0 ) 
  2266.       {
  2267.     if ( printednode != curp ) 
  2268.     {
  2269.       printnl ( 206 ) ; 
  2270.       if ( curp == 0 ) 
  2271.       shortdisplay ( mem [ printednode ] .hh .v.RH ) ; 
  2272.       else {
  2273.           
  2274.         savelink = mem [ curp ] .hh .v.RH ; 
  2275.         mem [ curp ] .hh .v.RH = 0 ; 
  2276.         printnl ( 206 ) ; 
  2277.         shortdisplay ( mem [ printednode ] .hh .v.RH ) ; 
  2278.         mem [ curp ] .hh .v.RH = savelink ; 
  2279.       } 
  2280.       printednode = curp ; 
  2281.     } 
  2282.     printnl ( 64 ) ; 
  2283.     if ( curp == 0 ) 
  2284.     printesc ( 455 ) ; 
  2285.     else if ( mem [ curp ] .hh.b0 != 10 ) 
  2286.     {
  2287.       if ( mem [ curp ] .hh.b0 == 12 ) 
  2288.       printesc ( 389 ) ; 
  2289.       else if ( mem [ curp ] .hh.b0 == 7 ) 
  2290.       printesc ( 217 ) ; 
  2291.       else if ( mem [ curp ] .hh.b0 == 11 ) 
  2292.       printesc ( 208 ) ; 
  2293.       else printesc ( 211 ) ; 
  2294.     } 
  2295.     print ( 783 ) ; 
  2296.     if ( mem [ r + 1 ] .hh .v.RH == 0 ) 
  2297.     printchar ( 48 ) ; 
  2298.     else printint ( mem [ mem [ r + 1 ] .hh .v.RH ] .hh .v.LH ) ; 
  2299.     print ( 784 ) ; 
  2300.     if ( artificialbadness ) 
  2301.     printchar ( 42 ) ; 
  2302.     else printint ( b ) ; 
  2303.     print ( 785 ) ; 
  2304.     printint ( pi ) ; 
  2305.     print ( 786 ) ; 
  2306.     printint ( d ) ; 
  2307.       } 
  2308. #endif /* STAT */
  2309.       d = d + mem [ r + 2 ] .cint ; 
  2310.       if ( d <= minimaldemerits [ fitclass ] ) 
  2311.       {
  2312.     minimaldemerits [ fitclass ] = d ; 
  2313.     bestplace [ fitclass ] = mem [ r + 1 ] .hh .v.RH ; 
  2314.     bestplline [ fitclass ] = l ; 
  2315.     if ( d < minimumdemerits ) 
  2316.     minimumdemerits = d ; 
  2317.       } 
  2318.       if ( noderstaysactive ) 
  2319.       goto lab22 ; 
  2320.       lab60: mem [ prevr ] .hh .v.RH = mem [ r ] .hh .v.RH ; 
  2321.       freenode ( r , 3 ) ; 
  2322.       if ( prevr == memtop - 7 ) 
  2323.       {
  2324.     r = mem [ memtop - 7 ] .hh .v.RH ; 
  2325.     if ( mem [ r ] .hh.b0 == 2 ) 
  2326.     {
  2327.       activewidth [ 1 ] = activewidth [ 1 ] + mem [ r + 1 ] .cint ; 
  2328.       activewidth [ 2 ] = activewidth [ 2 ] + mem [ r + 2 ] .cint ; 
  2329.       activewidth [ 3 ] = activewidth [ 3 ] + mem [ r + 3 ] .cint ; 
  2330.       activewidth [ 4 ] = activewidth [ 4 ] + mem [ r + 4 ] .cint ; 
  2331.       activewidth [ 5 ] = activewidth [ 5 ] + mem [ r + 5 ] .cint ; 
  2332.       activewidth [ 6 ] = activewidth [ 6 ] + mem [ r + 6 ] .cint ; 
  2333.       curactivewidth [ 1 ] = activewidth [ 1 ] ; 
  2334.       curactivewidth [ 2 ] = activewidth [ 2 ] ; 
  2335.       curactivewidth [ 3 ] = activewidth [ 3 ] ; 
  2336.       curactivewidth [ 4 ] = activewidth [ 4 ] ; 
  2337.       curactivewidth [ 5 ] = activewidth [ 5 ] ; 
  2338.       curactivewidth [ 6 ] = activewidth [ 6 ] ; 
  2339.       mem [ memtop - 7 ] .hh .v.RH = mem [ r ] .hh .v.RH ; 
  2340.       freenode ( r , 7 ) ; 
  2341.     } 
  2342.       } 
  2343.       else if ( mem [ prevr ] .hh.b0 == 2 ) 
  2344.       {
  2345.     r = mem [ prevr ] .hh .v.RH ; 
  2346.     if ( r == memtop - 7 ) 
  2347.     {
  2348.       curactivewidth [ 1 ] = curactivewidth [ 1 ] - mem [ prevr + 1 ] 
  2349.       .cint ; 
  2350.       curactivewidth [ 2 ] = curactivewidth [ 2 ] - mem [ prevr + 2 ] 
  2351.       .cint ; 
  2352.       curactivewidth [ 3 ] = curactivewidth [ 3 ] - mem [ prevr + 3 ] 
  2353.       .cint ; 
  2354.       curactivewidth [ 4 ] = curactivewidth [ 4 ] - mem [ prevr + 4 ] 
  2355.       .cint ; 
  2356.       curactivewidth [ 5 ] = curactivewidth [ 5 ] - mem [ prevr + 5 ] 
  2357.       .cint ; 
  2358.       curactivewidth [ 6 ] = curactivewidth [ 6 ] - mem [ prevr + 6 ] 
  2359.       .cint ; 
  2360.       mem [ prevprevr ] .hh .v.RH = memtop - 7 ; 
  2361.       freenode ( prevr , 7 ) ; 
  2362.       prevr = prevprevr ; 
  2363.     } 
  2364.     else if ( mem [ r ] .hh.b0 == 2 ) 
  2365.     {
  2366.       curactivewidth [ 1 ] = curactivewidth [ 1 ] + mem [ r + 1 ] .cint ; 
  2367.       curactivewidth [ 2 ] = curactivewidth [ 2 ] + mem [ r + 2 ] .cint ; 
  2368.       curactivewidth [ 3 ] = curactivewidth [ 3 ] + mem [ r + 3 ] .cint ; 
  2369.       curactivewidth [ 4 ] = curactivewidth [ 4 ] + mem [ r + 4 ] .cint ; 
  2370.       curactivewidth [ 5 ] = curactivewidth [ 5 ] + mem [ r + 5 ] .cint ; 
  2371.       curactivewidth [ 6 ] = curactivewidth [ 6 ] + mem [ r + 6 ] .cint ; 
  2372.       mem [ prevr + 1 ] .cint = mem [ prevr + 1 ] .cint + mem [ r + 1 ] 
  2373.       .cint ; 
  2374.       mem [ prevr + 2 ] .cint = mem [ prevr + 2 ] .cint + mem [ r + 2 ] 
  2375.       .cint ; 
  2376.       mem [ prevr + 3 ] .cint = mem [ prevr + 3 ] .cint + mem [ r + 3 ] 
  2377.       .cint ; 
  2378.       mem [ prevr + 4 ] .cint = mem [ prevr + 4 ] .cint + mem [ r + 4 ] 
  2379.       .cint ; 
  2380.       mem [ prevr + 5 ] .cint = mem [ prevr + 5 ] .cint + mem [ r + 5 ] 
  2381.       .cint ; 
  2382.       mem [ prevr + 6 ] .cint = mem [ prevr + 6 ] .cint + mem [ r + 6 ] 
  2383.       .cint ; 
  2384.       mem [ prevr ] .hh .v.RH = mem [ r ] .hh .v.RH ; 
  2385.       freenode ( r , 7 ) ; 
  2386.     } 
  2387.       } 
  2388.     } 
  2389.   } 
  2390.   lab10: 
  2391.     ;
  2392. #ifdef STAT
  2393.   if ( curp == printednode ) 
  2394.   if ( curp != 0 ) 
  2395.   if ( mem [ curp ] .hh.b0 == 7 ) 
  2396.   {
  2397.     t = mem [ curp ] .hh.b1 ; 
  2398.     while ( t > 0 ) {
  2399.     
  2400.       decr ( t ) ; 
  2401.       printednode = mem [ printednode ] .hh .v.RH ; 
  2402.     } 
  2403.   } 
  2404. #endif /* STAT */
  2405. } 
  2406.